LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaASSIGN(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::quaASSIGN(const Qua &qua) {
  // (:=,0,_,[esp+0])
  const string &dist = get<3>(qua);
  const string &src = get<1>(qua);
  if (dist == "eax" || src == "eax") {
    mov(dist, src);
  } else {
    mov("eax", src);
    mov(dist, "eax");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xf774(%rip), %rsi      # 0x477a9
movq %r14, %rdi
callq 0x40f0
testl %eax, %eax
je 0x3812f
leaq 0x40(%r14), %rdi
leaq 0xf759(%rip), %rsi      # 0x477a9
callq 0x40f0
testl %eax, %eax
je 0x3812f
leaq -0x90(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xf73a(%rip), %rsi      # 0x477a9
leaq 0xf736(%rip), %rdx      # 0x477ac
leaq -0xa0(%rbp), %rdi
callq 0xf868
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0xf7ca
leaq -0xa0(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movq %rbx, %rdi
callq 0x3a7d0
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x380c0
callq 0x42b0
movq -0xa0(%rbp), %rdi
cmpq %r15, %rdi
je 0x380d1
callq 0x42b0
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xf6ae(%rip), %rsi      # 0x477a9
leaq 0xf6aa(%rip), %rdx      # 0x477ac
leaq -0x40(%rbp), %rdi
callq 0xf868
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x3a7d0
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x38129
callq 0x42b0
movq -0x60(%rbp), %rdi
jmp 0x381a1
leaq -0xd0(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0xe0(%rbp), %rdi
callq 0xf7ca
leaq -0xb0(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0xc0(%rbp), %rdi
callq 0xf7ca
leaq -0xe0(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
movq %rbx, %rdi
callq 0x3a7d0
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3819a
callq 0x42b0
movq -0xe0(%rbp), %rdi
cmpq %r15, %rdi
je 0x381ab
callq 0x42b0
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x381d1
callq 0x42b0
jmp 0x381d1
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x38216
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x381ed
callq 0x42b0
jmp 0x381ed
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
jmp 0x38216
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3820f
callq 0x42b0
jmp 0x3820f
movq %rax, %rbx
movq -0xe0(%rbp), %rdi
cmpq %r15, %rdi
je 0x38220
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x38e38
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3916a
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 0xf7ca
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b386
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x391c1
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x391cf
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 0xf7ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b5fe
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x3920b
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39220
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 0x3925d
jmp 0x39278
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39254
callq 0x42b0
jmp 0x39254
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39278
callq 0x42b0
jmp 0x39278
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x39288
jmp 0x3928d
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3928d
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x38e38
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x392f6
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 0xf7ca
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b386
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3934d
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3935b
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 0xf7ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b6fa
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x39397
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x393ac
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 0x393e9
jmp 0x39404
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x393e0
callq 0x42b0
jmp 0x393e0
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39404
callq 0x42b0
jmp 0x39404
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x39414
jmp 0x39419
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39419
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x38e38
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x39482
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 0xf7ca
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b386
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x394d9
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x394e7
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 0xf7ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b7f6
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x39523
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39538
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 0x39575
jmp 0x39590
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3956c
callq 0x42b0
jmp 0x3956c
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39590
callq 0x42b0
jmp 0x39590
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x395a0
jmp 0x395a5
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x395a5
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x38e38
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3960e
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 0xf7ca
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b386
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39665
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39673
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 0xf7ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b8f2
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x396af
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x396c4
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 0x39701
jmp 0x3971c
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x396f8
callq 0x42b0
jmp 0x396f8
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3971c
callq 0x42b0
jmp 0x3971c
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x3972c
jmp 0x39731
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39731
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x38e38
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x3979a
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 0xf7ca
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b386
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x397f1
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x397ff
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 0xf7ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3b9ee
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x3983b
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39850
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 0x3988d
jmp 0x398a8
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39884
callq 0x42b0
jmp 0x39884
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x398a8
callq 0x42b0
jmp 0x398a8
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x398b8
jmp 0x398bd
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x398bd
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x38e38
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
je 0x39926
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 0xf7ca
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0xf7ca
leaq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x3b386
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x3997d
callq 0x42b0
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x3998b
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 0xf7ca
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x3baea
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x399c7
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x399dc
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 0x39a19
jmp 0x39a34
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x39a10
callq 0x42b0
jmp 0x39a10
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39a34
callq 0x42b0
jmp 0x39a34
movq %rax, %rbx
movq -0xc0(%rbp), %rdi
cmpq %r12, %rdi
jne 0x39a44
jmp 0x39a49
movq %rax, %rbx
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39a49
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0xf7ca
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
callq 0xf7ca
addq $0xa8, %rbx
leaq -0x88(%rbp), %rsi
movq %rbx, %rdi
callq 0x3bfd2
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x39ae4
callq 0x42b0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x39af2
callq 0x42b0
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x39b03
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 0x3bbe6
jmp 0x39b4a
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x39b39
callq 0x42b0
jmp 0x39b39
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x39b4a
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbaae(%rip), %rsi      # 0x45696
callq 0x40f0
testl %eax, %eax
je 0x39c59
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xdba9(%rip), %rsi      # 0x477a9
leaq 0xdba5(%rip), %rdx      # 0x477ac
leaq -0x60(%rbp), %rdi
callq 0xf868
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %rdi
callq 0xf7ca
leaq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x3a7d0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x39c4b
callq 0x42b0
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0x39c59
callq 0x42b0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xdb6b(%rip), %rsi      # 0x477d3
leaq 0xdb67(%rip), %rdx      # 0x477d6
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0xf868
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bc2e
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39c94
callq 0x42b0
movq (%rbx), %rbx
leaq 0x923b(%rip), %rsi      # 0x42ed9
movl $0x3, %edx
movq %rbx, %rdi
callq 0x4340
movq 0x22786(%rip), %rsi     # 0x5c438
movq 0x22787(%rip), %rdx     # 0x5c440
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 0x39ce4
callq 0x42b0
jmp 0x39ce4
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x39cf1
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x39cfb
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf7ca
movq (%rbx), %rdi
movq 0x226d9(%rip), %rsi     # 0x5c418
movq 0x226da(%rip), %rdx     # 0x5c420
callq 0x4340
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rax, %rdi
callq 0x4340
movq %rax, %r14
leaq 0xca9d(%rip), %rsi      # 0x46802
movl $0x1, %edx
movq %rax, %rdi
callq 0x4340
movq 0x226bf(%rip), %rsi     # 0x5c438
movq 0x226c0(%rip), %rdx     # 0x5c440
movq %r14, %rdi
callq 0x4340
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x39d96
callq 0x42b0
leaq -0x88(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xda2b(%rip), %rsi      # 0x477d3
leaq 0xda27(%rip), %rdx      # 0x477d6
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0xf868
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bd2a
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x39dda
callq 0x42b0
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd9ea(%rip), %rsi      # 0x477d3
leaq 0xd9e6(%rip), %rdx      # 0x477d6
leaq -0x78(%rbp), %rdi
callq 0xf868
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xd9b1(%rip), %rsi      # 0x477b9
leaq 0xd9ad(%rip), %rdx      # 0x477bc
leaq -0x58(%rbp), %rdi
callq 0xf868
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x3a7d0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x39e36
callq 0x42b0
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x39e44
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 0x39e68
callq 0x42b0
jmp 0x39e68
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
jne 0x39e8b
jmp 0x39e90
movq %rax, %rbx
movq -0x98(%rbp), %rdi
jmp 0x39e86
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x39e90
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f366
movq %r15, %rdi
movq %r12, %rsi
callq 0x3f464
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c708
callq 0x42b0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c71a
callq 0x42b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c72c
callq 0x42b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c741
callq 0x42b0
testq %r14, %r14
je 0x3c752
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x5c63
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 0x3efe2
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cb5c
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %rdi
callq 0xf7ca
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 0xf7ca
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xf7ca
leaq 0x28(%rbx), %rdi
leaq -0x90(%rbp), %rsi
callq 0x3f68c
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3d387
callq 0x42b0
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
leaq -0x80(%rbp), %r14
movq -0x30(%rbp), %r13
je 0x3d39d
callq 0x42b0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x3d3ae
callq 0x42b0
leaq -0x90(%rbp), %rdi
movq %r14, (%rdi)
leaq 0x7f81(%rip), %rsi      # 0x45340
leaq 0x7f7f(%rip), %rdx      # 0x45345
callq 0xf868
leaq -0x90(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x3c6c0
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x3d3fb
callq 0x42b0
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d418
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 0x3d489
jmp 0x3d493
jmp 0x3d490
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3f07e
jmp 0x3d493
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r14, %rdi
je 0x3d479
callq 0x42b0
jmp 0x3d479
movq %rax, %rbx
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x3d493
callq 0x42b0
jmp 0x3d493
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d4a8
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d39c
testl %eax, %eax
je 0x3eefb
movq %r12, %rdi
callq 0x2b2f4
leaq -0x58(%rbp), %r13
testb %al, %al
je 0x3ee30
movq %r13, -0x10(%r13)
leaq 0x6584(%rip), %rsi      # 0x4533d
leaq 0x657f(%rip), %rdx      # 0x4533f
leaq -0x68(%rbp), %rdi
callq 0xf868
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x3cf1e
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x68ae(%rip), %rsi      # 0x45696
leaq 0x68a8(%rip), %rdx      # 0x45697
leaq -0x48(%rbp), %rdi
callq 0xf868
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf118
leaq -0x68(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x88(%rbp), %r8
movq %r14, %rdi
movq %rbx, %r9
callq 0x3c6c0
jmp 0x3eeb8
movq %r13, -0x10(%r13)
leaq 0x6502(%rip), %rsi      # 0x4533d
leaq 0x64fd(%rip), %rdx      # 0x4533f
leaq -0x68(%rbp), %rdi
callq 0xf868
movq %r12, %rdi
callq 0x2b60a
leaq -0xa8(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xf118
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x6821(%rip), %rsi      # 0x45696
leaq 0x681b(%rip), %rdx      # 0x45697
leaq -0x48(%rbp), %rdi
callq 0xf868
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xf118
leaq -0x68(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
leaq -0x48(%rbp), %rcx
leaq -0x88(%rbp), %r8
movq %r14, %rdi
movq %rbx, %r9
callq 0x3c6c0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3eeca
callq 0x42b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3eed8
callq 0x42b0
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3eeed
callq 0x42b0
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3eefb
callq 0x42b0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ef11
jmp 0x3ef2a
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ef2d
callq 0x42b0
jmp 0x3ef2d
jmp 0x3ef3d
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3ef40
callq 0x42b0
jmp 0x3ef40
movq %rax, %rbx
leaq -0x98(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ef63
callq 0x42b0
jmp 0x3ef63
jmp 0x3ef60
jmp 0x3ef5b
movq %rax, %rbx
jmp 0x3ef71
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x3ef71
callq 0x42b0
movq %rbx, %rdi
callq 0x4560
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x1b2de
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xeb87
movq 0x28(%r14), %rcx
movq 0x38(%r14), %rdi
testq %rcx, %rcx
jne 0xeb09
testq %rdi, %rdi
jne 0xeb09
cmpq $0x0, 0x48(%r14)
jne 0xeb09
cmpq $0x0, 0x58(%r14)
je 0xeb87
movl $0x0, (%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
jmp 0xeb32
xorl %ebp, %ebp
movl $0x0, %ebx
testq %rcx, %rcx
je 0xeb23
movq %rcx, %rdi
callq 0xeabc
movl %eax, %ebx
movq 0x38(%r14), %rdi
movl %ebx, (%rsp)
testq %rdi, %rdi
je 0xeb32
callq 0xeabc
movl %eax, %ebp
movl %ebp, 0x4(%rsp)
movq 0x48(%r14), %rdi
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdi, %rdi
je 0xeb4b
callq 0xeabc
movl %eax, 0x8(%rsp)
movq 0x58(%r14), %rdi
testq %rdi, %rdi
je 0xeb5f
callq 0xeabc
movl %eax, %ebp
movq %rsp, %rax
movl %ebp, 0xc(%rax)
movl $0x4, %ecx
leaq (%rsp,%rcx), %rdx
movl (%rdx), %esi
cmpl %esi, %ebx
cmovlel %esi, %ebx
cmovlq %rdx, %rax
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0xeb6a
movl (%rax), %eax
incl %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b448
testb %al, %al
je 0x106b4
movslq 0x10(%rbx), %rax
testq %rax, %rax
jle 0x106cc
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 0x106a3
jmp 0x106f4
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x106d2
callq 0x1067c
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
jmp 0x106d6
xorpd %xmm1, %xmm1
jmp 0x106f4
xorpd %xmm1, %xmm1
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x106f4
movsd %xmm1, 0x8(%rsp)
callq 0x1067c
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1b448
testb %al, %al
je 0x108fc
xorl %r15d, %r15d
jmp 0x10930
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x10912
callq 0x108e6
movq %rax, %r15
jmp 0x10915
xorl %r15d, %r15d
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
je 0x1093a
addq %r14, %r15
movq %rbx, %rdi
callq 0x1b448
movq %r15, %r14
testb %al, %al
je 0x108ff
movq %r15, %r14
movslq (%rbx), %r15
imulq %r15, %r15
addq %r15, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b448
movq 0x28(%rbx), %rdi
movq 0x38(%rbx), %rcx
orq %rdi, %rcx
orq 0x48(%rbx), %rcx
setne %cl
testb %al, %al
je 0x1b21a
cmpq $0x0, 0x58(%rbx)
setne %al
orb %al, %cl
jne 0x1b2c8
movq 0x78(%rbx), %rax
movb $0x1, %bpl
cmpq 0x70(%rbx), %rax
jne 0x1b2d2
jmp 0x1b2c8
testb %cl, %cl
je 0x1b23d
testq %rdi, %rdi
je 0x1b24b
callq 0x1b1ce
movb $0x1, %bpl
testb %al, %al
je 0x1b24d
movq 0x28(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setge %bpl
jmp 0x1b24d
xorl %ebp, %ebp
cmpq $0x0, 0x58(%rbx)
jne 0x1b24d
jmp 0x1b2d2
xorl %ebp, %ebp
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x1b270
callq 0x1b1ce
movb $0x1, %r14b
testb %al, %al
je 0x1b273
movq 0x38(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setge %r14b
jmp 0x1b273
xorl %r14d, %r14d
movq 0x48(%rbx), %rdi
movb $0x1, %r15b
movb $0x1, %r12b
testq %rdi, %rdi
je 0x1b29c
callq 0x1b1ce
testb %al, %al
je 0x1b299
movq 0x48(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setl %r12b
jmp 0x1b29c
xorl %r12d, %r12d
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1b2bf
callq 0x1b1ce
testb %al, %al
je 0x1b2bc
movq 0x58(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setl %r15b
jmp 0x1b2bf
xorl %r15d, %r15d
orb %r14b, %bpl
testb $0x1, %bpl
je 0x1b2cc
xorl %ebp, %ebp
jmp 0x1b2d2
andb %r15b, %r12b
movl %r12d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ca01
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x1ca01
movq %rbx, %rdi
callq 0x1b448
testb %al, %al
je 0x1c9a3
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 0x1c9f5
addq $0x30, %r14
leaq 0x30(%rbx), %r15
movl $0x4, %r12d
movq -0x8(%r15), %rdi
movq -0x8(%r14), %rsi
testq %rdi, %rdi
je 0x1c9cc
testq %rsi, %rsi
je 0x1c9e8
xorl %edx, %edx
callq 0x1c932
jmp 0x1c9e8
testq %rsi, %rsi
je 0x1c9e8
movq %rsi, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c8e8
movq -0x8(%r15), %rax
movq %rbx, 0x68(%rax)
addq $0x10, %r14
addq $0x10, %r15
decq %r12
jne 0x1c9b1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x8534(%rip), %rsi      # 0x24f49
movq %rax, %rdi
callq 0x20a0
movq 0xf5cc(%rip), %rsi      # 0x2bff0
movq 0xf595(%rip), %rdx      # 0x2bfc0
movq %rbx, %rdi
callq 0x2290
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1baba
cmpq $0x0, 0x68(%rbx)
je 0x1f43d
movq %rbx, %rax
movq %rax, %rcx
movq 0x68(%rax), %rax
testq %rax, %rax
jne 0x1f41c
movl 0x8(%rcx), %r15d
movq %rbx, %rcx
movq %rcx, %rax
movq 0x68(%rcx), %rcx
testq %rcx, %rcx
jne 0x1f42f
jmp 0x1f444
movl 0x8(%rbx), %r15d
movq %rbx, %rax
movl 0xc(%rax), %r12d
movq %rbx, %rdi
callq 0x1b326
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x9986
cmpq $0x0, 0x68(%rbx)
jne 0x1f46e
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 0x1cda0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1f49f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1f4b6
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1f4cd
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f4dc
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1f4f5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1f50c
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1f523
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::symm_rk(hbsm::HierarchicalBlockSparseMatrix<double> const&, bool, hbsm::HierarchicalBlockSparseMatrix<double>&)
void HierarchicalBlockSparseMatrix<Treal>::symm_rk(HierarchicalBlockSparseMatrix<Treal> const & A, bool transposed, HierarchicalBlockSparseMatrix<Treal> & C){

            if(!C.empty()) throw std::runtime_error("Error in HierarchicalBlockSparseMatrix::symm_rk(): non-empty matrix to write result!");

            C.set_params(A.get_params());
            if(!transposed){
                std::shared_ptr<HierarchicalBlockSparseMatrix<Treal> > product;
								product = std::make_shared<HierarchicalBlockSparseMatrix<Treal> >();
                multiply(A, false, A, true, *product);
                product->get_upper_triangle(C);

            }
            else{
                std::shared_ptr<HierarchicalBlockSparseMatrix<Treal> > product;
								product = std::make_shared<HierarchicalBlockSparseMatrix<Treal> >();
                multiply(A, true, A, false, *product);
                product->get_upper_triangle(C);
            }

        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1b2de
testb %al, %al
je 0x20406
movl 0x10(%r15), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x9920
movl $0x98, %edi
callq 0x21c0
movq %rax, %r14
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0xb9c1(%rip), %rax      # 0x2bd18
movq %rax, (%r14)
leaq 0x10(%r14), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0xffffffff, 0x20(%r14) # imm = 0xFFFFFFFF
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
movups %xmm0, 0x88(%r14)
testb %bpl, %bpl
je 0x203c6
movq $0x0, (%rsp)
movq %r15, %rdi
movl $0x1, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xa4b0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2008a
jmp 0x203f1
movq $0x0, (%rsp)
movq %r15, %rdi
xorl %esi, %esi
movq %r15, %rdx
movl $0x1, %ecx
movq %r12, %r8
xorl %r9d, %r9d
callq 0xa4b0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2008a
movq %r14, %rdi
callq 0x1b482
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %r14
leaq 0x55d5(%rip), %rsi      # 0x259ef
movq %rax, %rdi
callq 0x20a0
movq 0xbbc7(%rip), %rsi      # 0x2bff0
movq 0xbb90(%rip), %rdx      # 0x2bfc0
movq %r14, %rdi
callq 0x2290
movq %rax, %rbx
movq %r14, %rdi
callq 0x2140
jmp 0x20452
jmp 0x20447
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b482
movq %rbx, %rdi
callq 0x22b0