LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39790
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x39ad8
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3bdb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39b2f
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39b3d
callq 0x42b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c030
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x39b79
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39b8e
callq 0x42b0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
jne 0x39bcb
jmp 0x39be6
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39bc2
callq 0x42b0
jmp 0x39bc2
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39be6
callq 0x42b0
jmp 0x39be6
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x39bf6
jmp 0x39bfb
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39bfb
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39790
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x39c64
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3bdb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39cbb
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39cc9
callq 0x42b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c12c
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x39d05
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39d1a
callq 0x42b0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
jne 0x39d57
jmp 0x39d72
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39d4e
callq 0x42b0
jmp 0x39d4e
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39d72
callq 0x42b0
jmp 0x39d72
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x39d82
jmp 0x39d87
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39d87
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39790
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x39df0
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3bdb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39e47
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39e55
callq 0x42b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c228
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x39e91
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39ea6
callq 0x42b0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
jne 0x39ee3
jmp 0x39efe
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39eda
callq 0x42b0
jmp 0x39eda
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39efe
callq 0x42b0
jmp 0x39efe
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x39f0e
jmp 0x39f13
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39f13
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39790
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x39f7c
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3bdb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39fd3
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39fe1
callq 0x42b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c324
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a01d
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a032
callq 0x42b0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
jne 0x3a06f
jmp 0x3a08a
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a066
callq 0x42b0
jmp 0x3a066
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a08a
callq 0x42b0
jmp 0x3a08a
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x3a09a
jmp 0x3a09f
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a09f
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39790
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a108
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3bdb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a15f
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a16d
callq 0x42b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c420
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a1a9
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a1be
callq 0x42b0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
jne 0x3a1fb
jmp 0x3a216
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a1f2
callq 0x42b0
jmp 0x3a1f2
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a216
callq 0x42b0
jmp 0x3a216
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x3a226
jmp 0x3a22b
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a22b
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
callq 0xf5c2
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x39790
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a294
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf5c2
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf5c2
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3bdb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a2eb
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a2f9
callq 0x42b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3c51c
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a335
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a34a
callq 0x42b0
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
jne 0x3a387
jmp 0x3a3a2
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a37e
callq 0x42b0
jmp 0x3a37e
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a3a2
callq 0x42b0
jmp 0x3a3a2
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x3a3b2
jmp 0x3a3b7
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a3b7
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0xf5c2
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0xf5c2
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
callq 0xf5c2
addq $0xa8, %rbx
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0x3ca04
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x3a452
callq 0x42b0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a460
callq 0x42b0
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a471
callq 0x42b0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3c618
jmp 0x3a4b8
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a4a7
callq 0x42b0
jmp 0x3a4a7
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a4b8
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsi), %rdi
leaq 0xc140(%rip), %rsi      # 0x46696
callq 0x40f0
testl %eax, %eax
je 0x3a5c7
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xe23b(%rip), %rsi      # 0x487a9
leaq 0xe237(%rip), %rdx      # 0x487ac
leaq -0x60(%rbp), %rdi
callq 0xf65c
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf5c2
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b202
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a5b9
callq 0x42b0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a5c7
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xe1fd(%rip), %rsi      # 0x487d3
leaq 0xe1f9(%rip), %rdx      # 0x487d6
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0xf65c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c660
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a602
callq 0x42b0
movq (%rbx), %rbx
leaq 0x98cd(%rip), %rsi      # 0x43ed9
movl $0x3, %edx
movq %rbx, %rdi
callq 0x4340
movq 0x22e18(%rip), %rsi     # 0x5d438
movq 0x22e19(%rip), %rdx     # 0x5d440
movq %rbx, %rdi
callq 0x4340
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x3a652
callq 0x42b0
jmp 0x3a652
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x3a65f
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a669
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xf5c2
movq (%rbx), %rdi
movq 0x22d6b(%rip), %rsi     # 0x5d418
movq 0x22d6c(%rip), %rdx     # 0x5d420
callq 0x4340
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rax, %rdi
callq 0x4340
movq %rax, %r14
leaq 0xd12f(%rip), %rsi      # 0x47802
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq 0x22d51(%rip), %rsi     # 0x5d438
movq 0x22d52(%rip), %rdx     # 0x5d440
movq %r14, %rdi
callq 0x4340
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a704
callq 0x42b0
leaq -0x88(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xe0bd(%rip), %rsi      # 0x487d3
leaq 0xe0b9(%rip), %rdx      # 0x487d6
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0xf65c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c75c
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a748
callq 0x42b0
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xe07c(%rip), %rsi      # 0x487d3
leaq 0xe078(%rip), %rdx      # 0x487d6
leaq -0x78(%rbp), %rdi
callq 0xf65c
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xe043(%rip), %rsi      # 0x487b9
leaq 0xe03f(%rip), %rdx      # 0x487bc
leaq -0x58(%rbp), %rdi
callq 0xf65c
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b202
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a7a4
callq 0x42b0
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x3a7b2
callq 0x42b0
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a7d6
callq 0x42b0
jmp 0x3a7d6
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
jne 0x3a7f9
jmp 0x3a7fe
movq %rax, %rbx
movq -0x98(%rbp), %rdi
jmp 0x3a7f4
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3a7fe
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %r9, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
callq 0x3fd2a
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fe28
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d074
callq 0x42b0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d086
callq 0x42b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d098
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d0ad
callq 0x42b0
testq %r14, %r14
je 0x3d0be
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x5c03
incq 0x8(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x3f9a6
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3d4c8
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %rdi
callq 0xf5c2
movq %r14, -0x30(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
addq %rsi, %rdx
callq 0xf5c2
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xf5c2
leaq 0x28(%rbx), %rdi
leaq -0x90(%rbp), %rsi
callq 0x40052
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3dd21
callq 0x42b0
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
leaq -0x80(%rbp), %r14
movq -0x30(%rbp), %r13
je 0x3dd37
callq 0x42b0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x3dd48
callq 0x42b0
leaq -0x90(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x85e7(%rip), %rsi      # 0x46340
leaq 0x85e5(%rip), %rdx      # 0x46345
callq 0xf65c
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x3d02c
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x3dd95
callq 0x42b0
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ddb2
callq 0x42b0
subq %r14, %rbx
sarq $0x5, %rbx
movabsq $0x5555555555555555, %rax # imm = 0x5555555555555555
imulq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
jne 0x3de23
jmp 0x3de2d
jmp 0x3de2a
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3fa42
jmp 0x3de2d
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x3de13
callq 0x42b0
jmp 0x3de13
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x3de2d
callq 0x42b0
jmp 0x3de2d
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3de42
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O1/acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::varDecEmit(unsigned long, ParseExpression const&, unsigned long, unsigned long)
void IR::varDecEmit(size_t addr, const ParseExpression &init_expr,
                    size_t node_id, size_t scope_id) {
  if (init_expr.get_expr_type() != ExpressionType::E_UNDEFINED) {
    if (init_expr.is_const()) {
      gen(":=", getConstValueStr(init_expr), "_", address2pointer(addr),
          node_id);
    } else {
      gen(":=", address2pointer(init_expr.get_address()), "_",
          address2pointer(addr), node_id);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2dc78
testl %eax, %eax
je 0x3f8bf
movq %r12, %rdi
callq 0x2bb90
leaq -0x58(%rbp), %r13
testb %al, %al
je 0x3f7f4
movq %r13, -0x10(%r13)
leaq 0x6bc0(%rip), %rsi      # 0x4633d
leaq 0x6bbb(%rip), %rdx      # 0x4633f
leaq -0x68(%rbp), %rdi
callq 0xf65c
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x3d8b8
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x6eea(%rip), %rsi      # 0x46696
leaq 0x6ee4(%rip), %rdx      # 0x46697
leaq -0x48(%rbp), %rdi
callq 0xf65c
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xef28
leaq -0x68(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x88(%rbp), %r8
movq %r14, %rdi
movq %rbx, %r9
callq 0x3d02c
jmp 0x3f87c
movq %r13, -0x10(%r13)
leaq 0x6b3e(%rip), %rsi      # 0x4633d
leaq 0x6b39(%rip), %rdx      # 0x4633f
leaq -0x68(%rbp), %rdi
callq 0xf65c
movq %r12, %rdi
callq 0x2be9c
leaq -0xa8(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xef28
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x6e5d(%rip), %rsi      # 0x46696
leaq 0x6e57(%rip), %rdx      # 0x46697
leaq -0x48(%rbp), %rdi
callq 0xf65c
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xef28
leaq -0x68(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x88(%rbp), %r8
movq %r14, %rdi
movq %rbx, %r9
callq 0x3d02c
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f88e
callq 0x42b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3f89c
callq 0x42b0
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f8b1
callq 0x42b0
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3f8bf
callq 0x42b0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f8d5
jmp 0x3f8ee
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f8f1
callq 0x42b0
jmp 0x3f8f1
jmp 0x3f901
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3f904
callq 0x42b0
jmp 0x3f904
movq %rax, %rbx
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3f927
callq 0x42b0
jmp 0x3f927
jmp 0x3f924
jmp 0x3f91f
movq %rax, %rbx
jmp 0x3f935
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3f935
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1ad92
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xea17
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
jne 0xe9a2
cmpq $0x0, 0x38(%rbx)
jne 0xe9a2
cmpq $0x0, 0x48(%rbx)
jne 0xe9a2
cmpq $0x0, 0x58(%rbx)
je 0xea17
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdi, %rdi
je 0xe9b3
callq 0xe96a
movl %eax, (%rsp)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xe9c6
callq 0xe96a
movl %eax, %ebp
movl %ebp, 0x4(%rsp)
movq 0x48(%rbx), %rdi
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdi, %rdi
je 0xe9df
callq 0xe96a
movl %eax, 0x8(%rsp)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xe9f3
callq 0xe96a
movl %eax, %ebp
movq %rsp, %rax
movl %ebp, 0xc(%rax)
movl $0x4, %ecx
movl (%rax), %edx
cmpl (%rsp,%rcx), %edx
jge 0xea09
leaq (%rsp,%rcx), %rax
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0xe9fe
movl (%rax), %eax
incl %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x1aed4
testb %al, %al
je 0x10564
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x1057c
leal 0x1(%rax), %ecx
movq 0x70(%rbx), %rdx
xorpd %xmm1, %xmm1
xorl %esi, %esi
movslq %esi, %rsi
addsd (%rdx,%rsi,8), %xmm1
addl %ecx, %esi
decq %rax
jne 0x10553
jmp 0x105a4
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x10582
callq 0x1052c
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
jmp 0x10586
xorpd %xmm1, %xmm1
jmp 0x105a4
xorpd %xmm1, %xmm1
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x105a4
movsd %xmm1, 0x8(%rsp)
callq 0x1052c
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1aed4
testb %al, %al
jne 0x107c5
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x107b5
callq 0x10790
jmp 0x107b7
xorl %eax, %eax
movq 0x58(%r14), %r14
testq %r14, %r14
je 0x107cc
addq %rax, %rbx
jmp 0x10799
movslq (%r14), %rax
imulq %rax, %rax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::check_if_matrix_is_consistent() const
bool HierarchicalBlockSparseMatrix<Treal>::check_if_matrix_is_consistent() const {

			if(lowest_level()){
				if(!children_exist() && submatrix.size() > 0) return true;
				else return false;
			}

			if(!children_exist()) return false;

			bool child0_ok = true, child1_ok = true, child2_ok = true, child3_ok = true;

			if(children[0]!=NULL) child0_ok = children[0]->check_if_matrix_is_consistent() && children[0]->nRows < nRows;
			if(children[1]!=NULL) child1_ok = children[1]->check_if_matrix_is_consistent() && children[1]->nRows < nRows;
			if(children[2]!=NULL) child2_ok = children[2]->check_if_matrix_is_consistent() && children[2]->nRows < nRows;
			if(children[3]!=NULL) child3_ok = children[3]->check_if_matrix_is_consistent() && children[3]->nRows < nRows;

			return child0_ok && child1_ok && child2_ok && child3_ok;

		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x1aed4
movq 0x28(%rbx), %rdi
movq 0x38(%rbx), %rcx
orq %rdi, %rcx
orq 0x48(%rbx), %rcx
orq 0x58(%rbx), %rcx
setne %cl
testb %al, %al
je 0x1acdc
testb %cl, %cl
jne 0x1ad80
movq 0x78(%rbx), %rax
movb $0x1, %bpl
cmpq 0x70(%rbx), %rax
jne 0x1ad82
jmp 0x1ad80
testb %cl, %cl
je 0x1ad80
testq %rdi, %rdi
je 0x1ad03
callq 0x1ac94
movb $0x1, %r14b
testb %al, %al
je 0x1ad06
movq 0x28(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setge %r14b
jmp 0x1ad06
xorl %r14d, %r14d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad29
callq 0x1ac94
movb $0x1, %r15b
testb %al, %al
je 0x1ad2c
movq 0x38(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setge %r15b
jmp 0x1ad2c
xorl %r15d, %r15d
movq 0x48(%rbx), %rdi
movb $0x1, %r12b
movb $0x1, %bpl
testq %rdi, %rdi
je 0x1ad54
callq 0x1ac94
testb %al, %al
je 0x1ad52
movq 0x48(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setl %bpl
jmp 0x1ad54
xorl %ebp, %ebp
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad77
callq 0x1ac94
testb %al, %al
je 0x1ad74
movq 0x58(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setl %r12b
jmp 0x1ad77
xorl %r12d, %r12d
orb %r15b, %r14b
testb $0x1, %r14b
je 0x1ad8d
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andb %r12b, %bpl
jmp 0x1ad82
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::add_to_first(hbsm::HierarchicalBlockSparseMatrix<double>&, hbsm::HierarchicalBlockSparseMatrix<double>&, unsigned long*)
void HierarchicalBlockSparseMatrix<Treal>::add_to_first(HierarchicalBlockSparseMatrix<Treal> & first, HierarchicalBlockSparseMatrix<Treal> & second,
													size_t* no_of_resizes){

			// at this point we are 100% sure that both matrices are non-empty!

			if(first.nRows_orig != second.nRows_orig || first.nCols_orig != second.nCols_orig ){
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix::add_to_first(): matrices to add have different sizes!");
			}

			if(first.lowest_level()){
				int blocksize = first.blocksize;
				int noOfElements = blocksize*blocksize;
				Treal const ONEreal = 1.0;
				int  const ONEint  = 1;

				// Add 1.0 * second to first.
				axpy(&noOfElements, &ONEreal, &second.submatrix[0], &ONEint, &first.submatrix[0], &ONEint);
				return;
			}

			for(int i = 0; i < 4; ++i){
				if(first.children[i] != NULL && second.children[i] == NULL){
					continue;
				}
				if(first.children[i] == NULL && second.children[i] != NULL) {
					first.children[i] = second.children[i];
					first.children[i]->parent = &first;
					continue;
				}
				if(first.children[i] != NULL && second.children[i] != NULL){
					add_to_first(*first.children[i],  *second.children[i]);
				}

			}


		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x1c4b6
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x1c4b6
movq %rbx, %rdi
callq 0x1aed4
testb %al, %al
je 0x1c443
movl 0x10(%rbx), %eax
imull %eax, %eax
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x70(%r14), %rdx
movq 0x70(%rbx), %r8
movq %rcx, %r9
callq 0x21e0
jmp 0x1c4aa
addq $0x30, %r14
leaq 0x30(%rbx), %r15
movl $0x4, %r12d
movq -0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1c461
cmpq $0x0, -0x8(%r14)
je 0x1c49d
testq %rdi, %rdi
je 0x1c47d
testq %rdi, %rdi
je 0x1c49d
movq -0x8(%r14), %rsi
testq %rsi, %rsi
je 0x1c49d
xorl %edx, %edx
callq 0x1c3d2
jmp 0x1c49d
movq -0x8(%r14), %rax
testq %rax, %rax
je 0x1c466
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c38c
movq -0x8(%r15), %rax
movq %rbx, 0x68(%rax)
addq $0x10, %r14
addq $0x10, %r15
decq %r12
jne 0x1c451
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x7a1f(%rip), %rsi      # 0x23ee9
movq %rax, %rdi
callq 0x20a0
movq 0xeb17(%rip), %rsi      # 0x2aff0
movq 0xeae0(%rip), %rdx      # 0x2afc0
movq %rbx, %rdi
callq 0x2290
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
leaq 0x20(%rsp), %rdx
movq %rax, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
movaps %xmm0, (%rcx)
callq 0x1b560
movq 0x68(%rbx), %rcx
movq %rbx, %rax
testq %rcx, %rcx
je 0x1ee53
movq %rbx, %rdx
movq %rdx, %rax
movq 0x68(%rdx), %rdx
testq %rdx, %rdx
jne 0x1ee47
movq %rbx, %rdx
testq %rcx, %rcx
je 0x1ee6a
movq %rbx, %rcx
movq %rcx, %rdx
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
jne 0x1ee5e
movl 0x8(%rax), %r15d
movl 0xc(%rdx), %r12d
movq %rbx, %rdi
callq 0x1adc6
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x99da
cmpq $0x0, 0x68(%rbx)
jne 0x1ee98
movl %r15d, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1c848
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1eec9
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1eee0
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1eef7
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ef06
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ef1f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1ef36
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1ef4d
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::sum_skips(std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<std::vector<unsigned long, std::allocator<unsigned long>>, std::allocator<std::vector<unsigned long, std::allocator<unsigned long>>>> const&)
std::vector<unsigned long int> HierarchicalBlockSparseMatrix<Treal>::sum_skips(std::vector<unsigned long int> const & curr_level_skips, std::vector<std::vector<unsigned long int> > const & sub_skips){

			  std::vector<unsigned long int> total_skips;
				total_skips.resize(curr_level_skips.size());

				for(int j = 0; j < curr_level_skips.size(); ++j){

					if(curr_level_skips[j] == 1) total_skips[j] = 1;
					else{
						for(int i = 0; i < sub_skips.size();++i){
							total_skips[j] += sub_skips[i][j];
						}
					}
				}

				return total_skips;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
callq 0x20f98
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0x210f5
sarq $0x3, %rcx
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movq %rsi, %r8
subq %rdx, %r8
sarq $0x3, %r8
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %r8, %rdi
movq (%rbx), %r8
cmpq $0x1, %rdi
adcq $0x0, %rdi
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %r9d, %r9d
cmpq $0x1, (%rax,%r9,8)
jne 0x210ca
movq $0x1, (%r8,%r9,8)
jmp 0x210ed
cmpq %rdx, %rsi
je 0x210ed
movq (%r8,%r9,8), %r10
movq %rdi, %r11
movq %rdx, %r14
movq (%r14), %r15
addq (%r15,%r9,8), %r10
movq %r10, (%r8,%r9,8)
addq $0x18, %r14
decq %r11
jne 0x210d9
incq %r9
cmpq %rcx, %r9
jne 0x210b9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x21115
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::sum_spamm_errors(std::vector<double, std::allocator<double>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
std::vector<Treal> HierarchicalBlockSparseMatrix<Treal>::sum_spamm_errors(std::vector<real> const & curr_level_errors, std::vector<std::vector<real> > const & sub_errors){

	 			  std::vector<real> total_errors(curr_level_errors.size(),0.0);


	 				for(int j = 0; j < curr_level_errors.size(); ++j){

					// WHAT IS COMMENTED OUT IS DUE TO THE NEW VERSION OF THE ALGORITHM PROPOSED BY EMANUEL
	 				//	if(curr_level_errors[j] > 0.0) total_errors[j] = curr_level_errors[j];
	 				//	else{
	 						for(int i = 0; i < sub_errors.size();++i){
								if(sub_errors[i].size() == 0) continue;
								else total_errors[j] += sub_errors[i][j] * sub_errors[i][j];
	 						}
							total_errors[j] = std::sqrt(total_errors[j]);
	 					//}
	 				}

	 				return total_errors;
	 		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
movq %rdi, %r15
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x7(%rsp), %rcx
callq 0x21c44
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x21728
xorl %r12d, %r12d
xorpd %xmm1, %xmm1
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x216ea
sarq $0x3, %rcx
imulq %r13, %rcx
movq (%r15), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
movq -0x8(%rax), %rsi
cmpq %rsi, (%rax)
je 0x216e1
movsd (%rsi,%r12,8), %xmm0
mulsd %xmm0, %xmm0
addsd (%rdx,%r12,8), %xmm0
movsd %xmm0, (%rdx,%r12,8)
addq $0x18, %rax
decq %rcx
jne 0x216c2
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd %xmm1, %xmm0
jb 0x216ff
sqrtsd %xmm0, %xmm0
jmp 0x21708
callq 0x2170
xorpd %xmm1, %xmm1
movq (%r15), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
cmpq %r12, %rax
ja 0x2169f
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: std::vector<double, std::allocator<double>> hbsm::operator+<double>(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b)
		{
		  assert(a.size() == b.size());

		  std::vector<T> result;
		  result.reserve(a.size());

		  std::transform(a.begin(), a.end(), b.begin(),
		                 std::back_inserter(result), std::plus<T>());
		  return result;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
movq 0x8(%rdx), %rax
subq (%rdx), %rax
cmpq %rax, %rsi
jne 0x21807
movq %rdx, %r14
movq %rdi, %rbx
sarq $0x3, %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x1c0da
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq (%r14), %rdx
movq %rbx, %rcx
callq 0x21ed2
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x360b(%rip), %rdi      # 0x24e19
leaq 0x1f2a(%rip), %rsi      # 0x2373f
leaq 0x3612(%rip), %rcx      # 0x24e2e
movl $0x1b6, %edx            # imm = 0x1B6
callq 0x2100
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2183d
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::self_frob_block_trunc(double)
bool HierarchicalBlockSparseMatrix<Treal>::self_frob_block_trunc(Treal trunc_value) {

			bool at_least_one_removed = false;

			for(int i = 0; i < 4; ++i){
				if(children[i] != NULL){ // if child exist
					if(children[i]->get_frob_squared() < trunc_value*trunc_value){
						children[i] = nullptr;
						at_least_one_removed = at_least_one_removed || true;
					}
					else{
						bool child_cleared = children[i]->self_frob_block_trunc(trunc_value);
						at_least_one_removed = at_least_one_removed || child_cleared;
					}
				}
			}


			for(int i = 0; i < 4; ++i){
				if(children[i] != NULL){
					if(!children[i]->lowest_level() && !children[i]->children_exist()){
						children[i] = nullptr;
					}
				}
			}

			return at_least_one_removed;

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd %xmm0, (%rsp)
mulsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x28(%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x21fba
callq 0x1ab74
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x21fa3
movq 0x30(%rbx,%r15), %rdi
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rbx,%r15)
movb $0x1, %r14b
testq %rdi, %rdi
je 0x21fba
callq 0x1af0e
jmp 0x21fba
movq 0x28(%rbx,%r15), %rdi
movsd (%rsp), %xmm0
callq 0x21f48
orb %r14b, %al
andb $0x1, %al
movl %eax, %r14d
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x21f69
xorl %r15d, %r15d
movq 0x28(%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x22015
callq 0x1aed4
testb %al, %al
jne 0x22015
movq 0x28(%rbx,%r15), %rax
cmpq $0x0, 0x28(%rax)
jne 0x22015
cmpq $0x0, 0x38(%rax)
jne 0x22015
cmpq $0x0, 0x48(%rax)
jne 0x22015
cmpq $0x0, 0x58(%rax)
jne 0x22015
movq 0x30(%rbx,%r15), %rdi
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rbx,%r15)
testq %rdi, %rdi
je 0x22015
callq 0x1af0e
addq $0x10, %r15
cmpq $0x40, %r15
jne 0x21fc7
andb $0x1, %r14b
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq