LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsi), %r12
leaq -0x80(%rbp), %rdi
callq 0x43a0
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x43a0
addq $0x40, %r15
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x43a0
addq $0xa8, %rbx
leaq -0x80(%rbp), %rsi
movq %rbx, %rdi
callq 0x32002
leaq -0x80(%rbp), %rdi
callq 0x12900
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x12900
jmp 0x30397
movq %rax, %rbx
movq %r14, %rdi
callq 0x4598
jmp 0x3038e
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %r14
leaq 0xa292(%rip), %rsi      # 0x3a6a2
movq %r14, %rdi
callq 0x31b63
testb %al, %al
je 0x3045e
leaq 0xc320(%rip), %rsi      # 0x3c743
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x4130
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
callq 0x43a0
leaq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x30c38
leaq -0x58(%rbp), %rdi
callq 0x4598
leaq -0x78(%rbp), %rdi
callq 0x4598
leaq 0xc308(%rip), %rsi      # 0x3c76d
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x4130
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x31b70
leaq -0x38(%rbp), %rdi
callq 0x4598
movq (%rbx), %rdi
leaq 0x7a60(%rip), %rsi      # 0x37ef1
callq 0x4280
leaq 0x23f6b(%rip), %rsi     # 0x54408
movq %rax, %rdi
callq 0x4250
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4598
jmp 0x304bf
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
jmp 0x304ce
jmp 0x304d5
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4598
jmp 0x304d8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x43a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31c44
leaq -0x98(%rbp), %rdi
callq 0x4598
leaq 0xc24f(%rip), %rsi      # 0x3c76d
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x4130
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x31c8c
leaq -0x78(%rbp), %rdi
callq 0x4598
leaq 0xc226(%rip), %rsi      # 0x3c76d
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x4130
leaq 0xc1f8(%rip), %rsi      # 0x3c753
leaq -0x38(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x4130
leaq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x30c38
leaq -0x38(%rbp), %rdi
callq 0x4598
leaq -0x58(%rbp), %rdi
callq 0x4598
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4598
jmp 0x305a7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0x305c7
jmp 0x305b8
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
jmp 0x305c7
movq %rax, %rbx
jmp 0x305cc
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/x86.hpp
// Function: x86::Assembler::cmp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline void cmp(string dist, string src) {
    static string cmpins = "cmp\tdword";
    of << T << "mov\tdword" << T << "eax" << C << dist << N;
    of << T << "mov\tdword" << T << "ebx" << C << src << N;
    of << T << cmpins << T << "eax" << C << "ebx" << N;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movq %rsi, %r12
movq %rdi, %rbx
movb 0x230ff(%rip), %al      # 0x545d0
testb %al, %al
je 0x315ff
movq (%rbx), %rdi
leaq 0x22f05(%rip), %r15     # 0x543e8
movq %r15, %rsi
callq 0x4250
leaq 0xb3a2(%rip), %r14      # 0x3c894
movq %rax, %rdi
movq %r14, %rsi
callq 0x4280
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
leaq 0xb234(%rip), %rsi      # 0x3c743
movq %rax, %rdi
callq 0x4280
leaq 0x22f0a(%rip), %r13     # 0x54428
movq %rax, %rdi
movq %r13, %rsi
callq 0x4250
movq %rax, %rdi
movq %r12, %rsi
callq 0x4250
leaq 0x22ecd(%rip), %r12     # 0x54408
movq %rax, %rdi
movq %r12, %rsi
callq 0x4250
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rdi
movq %r14, %rsi
callq 0x4280
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
leaq 0xb1d9(%rip), %r14      # 0x3c747
movq %rax, %rdi
movq %r14, %rsi
callq 0x4280
movq %rax, %rdi
movq %r13, %rsi
callq 0x4250
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x4250
movq %rax, %rdi
movq %r12, %rsi
callq 0x4250
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x4250
leaq 0x23003(%rip), %rsi     # 0x545b0
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rdi
leaq 0xb179(%rip), %rsi      # 0x3c743
callq 0x4280
movq %rax, %rdi
movq %r13, %rsi
callq 0x4250
movq %rax, %rdi
movq %r14, %rsi
callq 0x4280
movq %rax, %rdi
movq %r12, %rsi
callq 0x4250
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22fca(%rip), %rdi     # 0x545d0
callq 0x4510
testl %eax, %eax
je 0x314d9
leaq 0x22f96(%rip), %rdi     # 0x545b0
leaq 0xb269(%rip), %rsi      # 0x3c88a
leaq -0x29(%rbp), %rdx
callq 0x4130
movq 0x2197f(%rip), %rdi     # 0x52fb0
leaq 0x22f78(%rip), %rsi     # 0x545b0
leaq 0x21c91(%rip), %rdx     # 0x532d0
callq 0x4240
leaq 0x22f85(%rip), %rdi     # 0x545d0
callq 0x41f0
jmp 0x314d9
movq %rax, %rbx
leaq 0x22f71(%rip), %rdi     # 0x545d0
callq 0x41e0
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 0x342a4
movq %r15, %rdi
movq %r12, %rsi
callq 0x3435a
leaq -0xa0(%rbp), %rdi
callq 0x11786
testq %r14, %r14
je 0x326e7
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x53e0
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 0x11786
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::print()
void IR::print() {
  log("IR QUAS OUTPUT");
  for (int i = 0; i < quas.size(); i++) {
    cout << to_string(i) << "\t(" << get<0>(quas[i]) << "," << get<1>(quas[i])
         << "," << get<2>(quas[i]) << "," << get<3>(quas[i]) << ")" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xa1fc(%rip), %rsi      # 0x3c929
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x4130
leaq -0x50(%rbp), %rdi
callq 0x34148
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4598
xorl %r15d, %r15d
leaq 0x86ea(%rip), %r13      # 0x3ae43
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
sarq $0x7, %rax
cmpq %r12, %rax
jbe 0x32831
movq %r14, %rdi
movl %r12d, %esi
callq 0xc8ff
movq 0x20845(%rip), %rdi     # 0x52fc8
movq %r14, %rsi
callq 0x4250
movq %rax, %rdi
leaq 0x9f84(%rip), %rsi      # 0x3c719
callq 0x4280
movq 0x10(%rbx), %rcx
leaq (%rcx,%r15), %rsi
addq $0x60, %rsi
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
movq %r13, %rsi
callq 0x4280
movq 0x10(%rbx), %rcx
leaq (%rcx,%r15), %rsi
addq $0x40, %rsi
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
movq %r13, %rsi
callq 0x4280
movq 0x10(%rbx), %rcx
leaq (%rcx,%r15), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
movq %r13, %rsi
callq 0x4280
movq 0x10(%rbx), %rsi
addq %r15, %rsi
movq %rax, %rdi
callq 0x4250
movq %rax, %rdi
leaq 0x5d32(%rip), %rsi      # 0x38542
callq 0x4280
movq %rax, %rdi
callq 0x4170
movq %r14, %rdi
callq 0x4598
incq %r12
subq $-0x80, %r15
jmp 0x3275c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32847
movq %rax, %rbx
jmp 0x32853
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::size2type[abi:cxx11](unsigned long)
string IR::size2type(size_t size) {
  static map<size_t, string> mp = {{1, "db"}, {2, "dw"}, {4, "dd"}, {8, "dq"}};
  if (mp.find(size) == mp.end()) {
    log("other size: " + to_string(size));
    return "unknown";
  } else {
    return mp[size];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
movb 0x21e27(%rip), %al      # 0x54750
testb %al, %al
je 0x329da
leaq 0x21de8(%rip), %rdi     # 0x54720
leaq -0x30(%rbp), %rsi
callq 0x1e288
leaq 0x21de0(%rip), %rcx     # 0x54728
cmpq %rcx, %rax
je 0x3296a
leaq 0x21dcc(%rip), %rdi     # 0x54720
leaq -0x30(%rbp), %rsi
callq 0x30be6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x43a0
jmp 0x329c7
movq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %r14
movq %r14, %rdi
callq 0xc865
leaq 0x9fb7(%rip), %rsi      # 0x3c938
leaq -0x100(%rbp), %rdi
movq %r14, %rdx
callq 0xc837
leaq -0x100(%rbp), %rdi
callq 0x34148
leaq -0x100(%rbp), %rdi
callq 0x4598
leaq -0x60(%rbp), %rdi
callq 0x4598
leaq 0x7c5b(%rip), %rsi      # 0x3a613
leaq -0x100(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21d6f(%rip), %rdi     # 0x54750
callq 0x4510
testl %eax, %eax
je 0x32931
leaq -0x60(%rbp), %rsi
movl $0x1, (%rsi)
leaq 0x7965(%rip), %rdx      # 0x3a364
leaq -0x100(%rbp), %r14
movq %r14, %rdi
callq 0x11a7e
leaq -0xd8(%rbp), %r15
leaq -0x3c(%rbp), %rsi
movl $0x2, (%rsi)
leaq 0x7941(%rip), %rdx      # 0x3a367
movq %r15, %rdi
callq 0x11a7e
leaq -0xb0(%rbp), %r15
leaq -0x38(%rbp), %rsi
movl $0x4, (%rsi)
leaq 0x9e23(%rip), %rdx      # 0x3c869
movq %r15, %rdi
callq 0x11a7e
leaq -0x88(%rbp), %r15
leaq -0x34(%rbp), %rsi
movl $0x8, (%rsi)
leaq 0x7904(%rip), %rdx      # 0x3a36a
movq %r15, %rdi
callq 0x11a7e
leaq 0x21cab(%rip), %rdi     # 0x54720
leaq -0x100(%rbp), %rsi
pushq $0x4
popq %rdx
leaq -0x22(%rbp), %rcx
leaq -0x21(%rbp), %r8
callq 0x11aa6
movl $0x80, %r14d
leaq (%r14,%rbp), %rdi
addq $-0x100, %rdi
callq 0x4598
addq $-0x28, %r14
cmpq $-0x20, %r14
jne 0x32a92
leaq 0x16cb(%rip), %rdi      # 0x3417e
leaq 0x21c66(%rip), %rsi     # 0x54720
leaq 0x2080f(%rip), %rdx     # 0x532d0
callq 0x4240
leaq 0x21c83(%rip), %rdi     # 0x54750
callq 0x41f0
jmp 0x32931
movq %rax, %rbx
movl $0x80, %r14d
leaq (%r14,%rbp), %rdi
addq $-0x100, %rdi
callq 0x4598
addq $-0x28, %r14
cmpq $-0x20, %r14
jne 0x32ae0
jmp 0x32b20
jmp 0x32b00
jmp 0x32b00
movq %rax, %rbx
leaq -0x28(%r15), %r12
addq $-0x20, %r15
movq %r15, %rdi
callq 0x4598
movq %r12, %r15
cmpq %r14, %r12
jne 0x32b03
jmp 0x32b20
movq %rax, %rbx
leaq 0x21c29(%rip), %rdi     # 0x54750
callq 0x41e0
jmp 0x32b4b
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x4598
jmp 0x32b42
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::getConstValueStr[abi:cxx11](ParseExpression const&)
string IR::getConstValueStr(const ParseExpression &init_expr) {
  const ParseConstant &E = init_expr.get_const();
  ConstValueType con_type = E.get_type();
  string arg1;
  switch (con_type) {
  case ConstValueType::C_SIGNED:
    return to_string((int)E.get_signed());
  case ConstValueType::C_UNSIGNED:
    return to_string((int)E.get_unsigned());
  case ConstValueType::C_FLOAT:
    return to_string((int)E.get_float());
  case ConstValueType::C_BOOL:
    return to_string((int)E.get_bool());
  case ConstValueType::C_STRING:
    return E.get_string();
  default:
    log("other constant type");
    break;
  }
  return "BadValue";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x25daa
movq %rax, %r14
movq %rax, %rdi
callq 0x27fba
leaq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
cmpl $0x4, %eax
ja 0x32c22
movl %eax, %eax
leaq 0x9d29(%rip), %rcx      # 0x3c8c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27cde
fldz
jmp 0x32c0b
movq %r14, %rdi
callq 0x27c88
fldz
fstp %st(0)
movzbl %al, %esi
jmp 0x32c01
movq %r14, %rdi
callq 0x27b82
fldz
jmp 0x32bfc
movq %r14, %rdi
callq 0x27c08
fnstcw -0x12(%rbp)
movzwl -0x12(%rbp), %eax
orl $0xc00, %eax            # imm = 0xC00
movw %ax, -0x14(%rbp)
fldcw -0x14(%rbp)
fistpl -0x1c(%rbp)
fldcw -0x12(%rbp)
movl -0x1c(%rbp), %esi
jmp 0x32c01
movq %r14, %rdi
callq 0x27b16
fldz
movq %rax, %rsi
fstp %st(0)
movq %rbx, %rdi
callq 0xc8ff
fldz
fstp %st(0)
leaq -0x60(%rbp), %rdi
callq 0x4598
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9d1c(%rip), %rsi      # 0x3c945
leaq -0x40(%rbp), %rdi
leaq -0x15(%rbp), %rdx
callq 0x4130
leaq -0x40(%rbp), %rdi
callq 0x34148
leaq -0x40(%rbp), %rdi
callq 0x4598
leaq 0x9d0a(%rip), %rsi      # 0x3c959
leaq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x4130
fldz
jmp 0x32c0b
jmp 0x32c73
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4598
jmp 0x32c76
jmp 0x32c73
fstp %st(0)
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x50(%rbp), %rdi
callq 0x3290a
leaq -0xb0(%rbp), %rdi
movq %r12, %rsi
callq 0x43a0
leaq -0x90(%rbp), %r13
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
callq 0x43a0
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0x43a0
leaq 0x28(%rbx), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x3450c
leaq -0xb0(%rbp), %rdi
callq 0x11722
leaq 0x764a(%rip), %rsi      # 0x3a34c
leaq -0xb0(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x4130
leaq -0xb0(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r8
movq %r14, %r9
callq 0x32694
leaq -0xb0(%rbp), %rdi
callq 0x4598
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
pushq $-0x60
popq %rcx
cqto
idivq %rcx
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32d8d
jmp 0x32d9e
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x11722
jmp 0x32da1
movq %rax, %rbx
movq %r13, %rdi
callq 0x4598
jmp 0x32d90
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x4598
jmp 0x32da1
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::getItemEmit(ParseExpression const&, ParseType const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ParseTree&, unsigned long, unsigned long)
size_t IR::getItemEmit(const ParseExpression &init_expr,
                       const ParseType &this_type, const string &symbol,
                       ParseTree &tree, size_t node_id, size_t scope_id) {
  vector<size_t> psize;
  vector<size_t> pid;
  psize.push_back(init_expr.get_ret_type().get_size());
  size_t esp = dfsArrayGetItem(init_expr, psize, pid);
  for (int i = 1; i < psize.size(); i++) {
    psize[i] *= psize[i - 1];
  }
  size_t pos = 0;
  if (psize.size() == pid.size() + 1) {
    for (int i = 0; i <= pid.size() - 1; i++) {
      pos += pid[i] * psize[i];
    }
  } else {
    throw ParseException(ExceptionCode::EX_UNKNOWN,
                         "IR::getItemEmit: Bad Array Type " +
                             init_expr.get_info());
  }
  init_expr.set_address(esp + pos);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
andq $0x0, -0x20(%rbp)
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movq %rsi, %rdi
callq 0x249b0
movq %rax, %rdi
callq 0x21bec
leaq -0x70(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x30(%rbp), %rdi
callq 0x1679a
leaq -0x30(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32e62
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
pushq $0x1
popq %rdx
cmpq %rdx, %rsi
jbe 0x330dd
movq (%rcx,%rdx,8), %rdi
imulq -0x8(%rcx,%rdx,8), %rdi
movq %rdi, (%rcx,%rdx,8)
incq %rdx
jmp 0x330c5
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rdi
subq %rdx, %rdi
sarq $0x3, %rdi
leaq 0x1(%rdi), %r8
cmpq %r8, %rsi
jne 0x3313a
xorl %r8d, %r8d
xorl %esi, %esi
cmpq %r8, %rdi
je 0x33110
movq (%rcx,%r8,8), %r9
imulq (%rdx,%r8,8), %r9
addq %r9, %rsi
incq %r8
jmp 0x330fa
addq %rax, %rsi
movq %rbx, %rdi
callq 0x26412
leaq -0x50(%rbp), %rdi
callq 0xd238
leaq -0x30(%rbp), %rdi
callq 0xd238
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x4180
movq %rax, %r14
leaq -0x90(%rbp), %rdi
movq %rbx, %rsi
callq 0x24204
leaq 0x9892(%rip), %rsi      # 0x3c9ed
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xc837
movb $0x1, %r15b
leaq -0x70(%rbp), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2b53c
xorl %r15d, %r15d
leaq 0x1fbea(%rip), %rsi     # 0x52d70
leaq -0x268e5(%rip), %rdx    # 0xc8a8
movq %r14, %rdi
callq 0x44e0
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x4598
jmp 0x331a9
movq %rax, %rbx
movb $0x1, %r15b
leaq -0x90(%rbp), %rdi
callq 0x4598
testb %r15b, %r15b
jne 0x331bf
jmp 0x331d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x331d0
jmp 0x331cd
jmp 0x331cd
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xd238
leaq -0x30(%rbp), %rdi
callq 0xd238
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x90, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0x26408
testl %eax, %eax
je 0x3407d
movq %r12, %rdi
callq 0x24972
testb %al, %al
je 0x33fde
leaq 0x63d0(%rip), %rsi      # 0x3a349
leaq -0xa8(%rbp), %rdi
leaq -0x22(%rbp), %rdx
callq 0x4130
leaq -0x88(%rbp), %rdi
movq %r12, %rsi
callq 0x32b54
leaq 0x6703(%rip), %rsi      # 0x3a6a2
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x4130
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xd2ea
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %r8
movq %r14, %rdi
movq %rbx, %r9
callq 0x32694
jmp 0x34053
leaq 0x6364(%rip), %rsi      # 0x3a349
leaq -0xa8(%rbp), %rdi
leaq -0x22(%rbp), %rdx
callq 0x4130
movq %r12, %rdi
callq 0x24c42
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xd2ea
leaq 0x668c(%rip), %rsi      # 0x3a6a2
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x4130
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xd2ea
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0x68(%rbp), %rcx
leaq -0x48(%rbp), %r8
movq %r14, %rdi
movq %rbx, %r9
callq 0x32694
leaq -0x48(%rbp), %rdi
callq 0x4598
leaq -0x68(%rbp), %rdi
callq 0x4598
leaq -0x88(%rbp), %rdi
callq 0x4598
leaq -0xa8(%rbp), %rdi
callq 0x4598
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x34091
jmp 0x340a1
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4598
jmp 0x340a4
jmp 0x340af
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x4598
jmp 0x340b2
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4598
jmp 0x340cc
jmp 0x340c9
jmp 0x340c4
movq %rax, %rbx
jmp 0x340d8
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x4598
movq %rbx, %rdi
callq 0x4500
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14e3a
xorl %ebp, %ebp
testb %al, %al
jne 0xbe2b
movq %rbx, %rdi
callq 0x14e62
testb %al, %al
je 0xbe2b
movq 0x28(%rbx), %rdi
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdi, %rdi
je 0xbdd7
callq 0xbda2
movl %eax, (%rsp)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xbdea
callq 0xbda2
movl %eax, %ebp
movl %ebp, 0x4(%rsp)
movq 0x48(%rbx), %rdi
xorl %ebp, %ebp
movl $0x0, %eax
testq %rdi, %rdi
je 0xbe03
callq 0xbda2
movl %eax, 0x8(%rsp)
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xbe17
callq 0xbda2
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
movl %ebp, -0x4(%rsi)
movq %rsp, %rdi
callq 0x17205
movl (%rax), %ebp
incl %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::print() const
void print() const{
				std::vector<int> rows, cols;
				std::vector<Treal> vals;
				get_all_values(rows, cols, vals);
				for(int i = 0; i < rows.size(); ++i){
					std::cout << rows[i] << " " << cols[i] << " " << vals[i] << std::endl;
				}
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsp, %rsi
andq $0x0, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq 0x40(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
callq 0x15770
xorl %r15d, %r15d
movq 0x1a15c(%rip), %rbx     # 0x25fd0
leaq 0x106d2(%rip), %r14     # 0x1c54d
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r15, %rcx
jbe 0xbee3
movl (%rax,%r15,4), %esi
movq %rbx, %rdi
callq 0x2280
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
movq 0x40(%rsp), %rcx
movl (%rcx,%r15,4), %esi
movq %rax, %rdi
callq 0x2280
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
movq 0x20(%rsp), %rcx
movsd (%rcx,%r15,8), %xmm0
movq %rax, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x20c0
incq %r15
jmp 0xbe7b
leaq 0x20(%rsp), %rdi
callq 0x1722c
leaq 0x40(%rsp), %rdi
callq 0x1724a
movq %rsp, %rdi
callq 0x1724a
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xbf0b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1722c
leaq 0x40(%rsp), %rdi
callq 0x1724a
movq %rsp, %rdi
callq 0x1724a
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::rescale(hbsm::HierarchicalBlockSparseMatrix<double> const&, double)
void HierarchicalBlockSparseMatrix<Treal>::rescale(HierarchicalBlockSparseMatrix<Treal> const & other, Treal alpha){

			if(!empty()) throw std::runtime_error("Error in HierarchicalBlockSparseMatrix::rescale(): non-empty matrix called this method!");

            if(other.empty()){
                clear();
                return;
            }

			set_params(other.get_params());
            resize(other.nRows_orig,other.nCols_orig);

            if(other.lowest_level()){
                for(int i = 0; i < nRows * nCols; ++i) submatrix[i] = other.submatrix[i] * alpha;
                return;
            }

            for(int i = 0; i < 4; ++i){
                if(children[i] != NULL)
                    throw std::runtime_error("Error in HierarchicalBlockSparseMatrix::rescale(): non-null child exist!");

                if(other.children[i] != NULL){
                    children[i] = std::make_shared<HierarchicalBlockSparseMatrix<Treal> >();
                    children[i]->rescale(*other.children[i], alpha);
										children[i]->parent = this;
                }

            }

		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0x14e3a
testb %al, %al
je 0xca36
movq %r14, %rdi
callq 0x14e3a
testb %al, %al
je 0xc934
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14e82
movl 0x10(%r14), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x7cc0
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x7d24
movq %r14, %rdi
callq 0x14f94
testb %al, %al
je 0xc997
movl 0x4(%rbx), %eax
imull (%rbx), %eax
movq 0x70(%r14), %rcx
movq 0x70(%rbx), %rdx
testl %eax, %eax
cmovlel %r15d, %eax
cmpq %r15, %rax
je 0xc9f7
movsd (%rcx,%r15,8), %xmm0
mulsd (%rsp), %xmm0
movsd %xmm0, (%rdx,%r15,8)
incq %r15
jmp 0xc97c
pushq $0x28
popq %rbp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq $0x68, %rbp
je 0xc9f7
cmpq $0x0, (%rbx,%rbp)
jne 0xca06
cmpq $0x0, (%r14,%rbp)
je 0xc9f1
leaq (%rbx,%rbp), %r13
movq %r12, %rdi
callq 0x152ec
movq %r13, %rdi
movq %r12, %rsi
callq 0x14fba
movq %r15, %rdi
callq 0x14fe8
movq (%rbx,%rbp), %rdi
movq (%r14,%rbp), %rsi
movsd (%rsp), %xmm0
callq 0xc8ec
movq (%rbx,%rbp), %rax
movq %rbx, 0x68(%rax)
addq $0x10, %rbp
jmp 0xc9a4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x10945(%rip), %rsi     # 0x1d35d
movq %rax, %rdi
callq 0x2080
movq 0x195c9(%rip), %rsi     # 0x25ff0
movq 0x19592(%rip), %rdx     # 0x25fc0
movq %rbx, %rdi
callq 0x2270
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x108bd(%rip), %rsi     # 0x1d305
movq %rax, %rdi
callq 0x2080
jmp 0xca20
jmp 0xca54
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14f94
testb %al, %al
je 0xd404
movl 0x10(%rbx), %eax
leal 0x1(%rax), %ecx
movq 0x70(%rbx), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm1, %xmm1
subq $0x1, %rax
jb 0xd43e
movslq %esi, %rsi
addsd (%rdx,%rsi,8), %xmm1
addl %ecx, %esi
jmp 0xd3f2
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xd41c
callq 0xd3cc
xorpd %xmm1, %xmm1
addsd %xmm0, %xmm1
jmp 0xd420
xorpd %xmm1, %xmm1
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xd43e
movsd %xmm1, 0x8(%rsp)
callq 0xd3cc
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::set_to_identity(hbsm::HierarchicalBlockSparseMatrix<double>&, int)
void HierarchicalBlockSparseMatrix<Treal>::set_to_identity(HierarchicalBlockSparseMatrix<Treal> & A, int nRows) {

            // assume params are set

            A.clear();

            A.resize(nRows, nRows);

            if(A.lowest_level()){

                int blocksize = A.blocksize;
								int n = A.nRows;
								if(A.on_bottom_boundary()) n = A.get_n_rows() % blocksize; // fill only necessary elements

                for(int i = 0; i < n; ++i) A.submatrix[i*blocksize + i] = 1.0;

                return;
            }

            int blocksize = A.blocksize;

            A.children[0] = std::make_shared<HierarchicalBlockSparseMatrix<Treal> >();
            A.children[0]->parent = &A;
            A.children[0]->set_params(A.get_params());
            set_to_identity(*A.children[0], A.nRows/2);

            if(A.children[0]->get_first_row_position() + A.children[0]->nRows >= A.get_n_rows() ) return;

            A.children[3] = std::make_shared<HierarchicalBlockSparseMatrix<Treal> >();
            A.children[3]->parent = &A;
            A.children[3]->set_params(A.get_params());
            set_to_identity(*A.children[3], A.nRows/2);

            return;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x14e82
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x7d24
movq %rbx, %rdi
callq 0x14f94
testb %al, %al
je 0xd4c4
movl (%rbx), %r14d
movl 0x10(%rbx), %ebp
movq %rbx, %rdi
callq 0x15236
testb %al, %al
je 0xd496
movq %rbx, %rdi
callq 0x15274
cltd
idivl %ebp
movl %edx, %r14d
incl %ebp
movq 0x70(%rbx), %rax
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
subq $0x1, %r14
jb 0xd585
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addl %ebp, %ecx
jmp 0xd4af
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x152ec
leaq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0x14fba
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x14fe8
movq 0x28(%rbx), %rdi
movq %rbx, 0x68(%rdi)
movl 0x10(%rbx), %eax
movl %eax, -0x8(%r14)
leaq 0x8(%rsp), %rsi
callq 0x7cc0
movq 0x28(%rbx), %rdi
movl (%rbx), %eax
pushq $0x2
popq %r15
cltd
idivl %r15d
movl %eax, %esi
callq 0xd448
movq 0x28(%rbx), %rdi
callq 0x15308
movl %eax, %ebp
movq 0x28(%rbx), %rax
addl (%rax), %ebp
movq %rbx, %rdi
callq 0x15274
cmpl %eax, %ebp
jge 0xd585
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x152ec
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x14fba
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x14fe8
movq 0x58(%rbx), %rdi
movq %rbx, 0x68(%rdi)
movl 0x10(%rbx), %eax
movl %eax, -0x8(%r14)
leaq 0x8(%rsp), %rsi
callq 0x7cc0
movq 0x58(%rbx), %rdi
movl (%rbx), %eax
cltd
idivl %r15d
movl %eax, %esi
callq 0xd448
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x14f94
testb %al, %al
jne 0xd5c6
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xd5b6
callq 0xd590
jmp 0xd5b8
xorl %eax, %eax
movq 0x58(%rbx), %rbx
testq %rbx, %rbx
je 0xd5cd
addq %rax, %r14
jmp 0xd59a
movslq (%rbx), %rax
imulq %rax, %rax
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14f94
movl %eax, %ebp
movq %rbx, %rdi
callq 0x14e62
testb %bpl, %bpl
je 0x14d7f
testb %al, %al
jne 0x14e27
movq 0x78(%rbx), %rax
movb $0x1, %bpl
cmpq 0x70(%rbx), %rax
jne 0x14e29
jmp 0x14e27
testb %al, %al
je 0x14e27
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x14daa
callq 0x14d42
movb $0x1, %r14b
testb %al, %al
je 0x14dad
movq 0x28(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setge %r14b
jmp 0x14dad
xorl %r14d, %r14d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x14dd0
callq 0x14d42
movb $0x1, %r15b
testb %al, %al
je 0x14dd3
movq 0x38(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setge %r15b
jmp 0x14dd3
xorl %r15d, %r15d
movq 0x48(%rbx), %rdi
movb $0x1, %r12b
movb $0x1, %bpl
testq %rdi, %rdi
je 0x14dfb
callq 0x14d42
testb %al, %al
je 0x14df9
movq 0x48(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setl %bpl
jmp 0x14dfb
xorl %ebp, %ebp
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x14e1e
callq 0x14d42
testb %al, %al
je 0x14e1b
movq 0x58(%rbx), %rax
movl (%rax), %eax
cmpl (%rbx), %eax
setl %r12b
jmp 0x14e1e
xorl %r12d, %r12d
orb %r15b, %r14b
testb $0x1, %r14b
je 0x14e34
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andb %r12b, %bpl
jmp 0x14e29
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1646e
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %eax
cmpl 0xc(%rsi), %eax
jne 0x1646e
movq %rbx, %rdi
callq 0x14f94
testb %al, %al
je 0x16427
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 0x21d0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x28
popq %r12
cmpq $0x68, %r12
je 0x1641b
movq (%rbx,%r12), %rdi
movq (%r14,%r12), %rsi
testq %rdi, %rdi
je 0x1644c
testq %rsi, %rsi
je 0x16468
xorl %edx, %edx
callq 0x163ac
jmp 0x16468
testq %rsi, %rsi
je 0x16468
leaq (%rbx,%r12), %r15
leaq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0x162fc
movq (%r15), %rax
movq %rbx, 0x68(%rax)
addq $0x10, %r12
jmp 0x1642b
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x6a79(%rip), %rsi      # 0x1cef9
movq %rax, %rdi
callq 0x2080
movq 0xfb61(%rip), %rsi      # 0x25ff0
movq 0xfb2a(%rip), %rdx      # 0x25fc0
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x40(%rsp), %rsi
andq $0x0, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
callq 0x15770
movq %rbx, %rdi
callq 0x15274
movl %eax, %r15d
movq %rbx, %rdi
callq 0x152d0
movl %eax, %r12d
movq %rbx, %rdi
callq 0x14e82
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x7d24
cmpq $0x0, 0x68(%rbx)
jne 0x18349
movl %r15d, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %rbx, %rdi
callq 0xbd96
movq %rsp, %rdi
callq 0x1722c
leaq 0x20(%rsp), %rdi
callq 0x1724a
leaq 0x40(%rsp), %rdi
callq 0x1724a
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x18389
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1722c
leaq 0x20(%rsp), %rdi
callq 0x1724a
leaq 0x40(%rsp), %rdi
callq 0x1724a
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x14e3a
testb %al, %al
je 0x18ee6
movl 0x10(%r14), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x7cc0
xorps %xmm0, %xmm0
testb %bpl, %bpl
je 0x18e7e
movaps %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x152ec
leaq 0x10(%rsp), %r15
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x14fba
leaq 0x30(%rsp), %rdi
callq 0x14fe8
movq (%r15), %r8
andq $0x0, (%rsp)
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x8572
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x18c36
jmp 0x18ed1
movaps %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x152ec
leaq 0x10(%rsp), %r15
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x14fba
leaq 0x30(%rsp), %rdi
callq 0x14fe8
movq (%r15), %r8
andq $0x0, (%rsp)
pushq $0x1
popq %rcx
movq %r14, %rdi
xorl %esi, %esi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x8572
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x18c36
leaq 0x18(%rsp), %rdi
callq 0x14fe8
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x4aa7(%rip), %rsi      # 0x1d99f
movq %rax, %rdi
callq 0x2080
movq 0xd0e9(%rip), %rsi      # 0x25ff0
movq 0xd0b2(%rip), %rdx      # 0x25fc0
movq %r14, %rdi
callq 0x2270
jmp 0x18f29
jmp 0x18f29
movq %rax, %rbx
movq %r14, %rdi
callq 0x2130
jmp 0x18f36
jmp 0x18f29
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x14fe8
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
callq 0x1a02c
movq (%r15), %rcx
movq 0x8(%r15), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
pushq $0x18
popq %r8
cqto
idivq %r8
movq (%rbx), %rdx
xorl %r8d, %r8d
cmpq %rsi, %r8
je 0x1a13d
cmpq $0x1, (%rcx,%r8,8)
jne 0x1a11d
movq $0x1, (%rdx,%r8,8)
incq %r8
jmp 0x1a104
movq (%rbx), %r9
movq %rdi, %r10
movq %rax, %r11
subq $0x1, %r11
jb 0x1a118
movq (%r10), %r14
movq (%r14,%r8,8), %r14
addq %r14, (%r9,%r8,8)
addq $0x18, %r10
jmp 0x1a126
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a378
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_max_abs_value() const
Treal HierarchicalBlockSparseMatrix<Treal>::get_max_abs_value() const {
				std::vector<Treal> all_values;
				std::vector<int> rows, cols;

				get_all_values(rows,cols,all_values);

				Treal max_abs_value = 0.0;

				for(auto i = 0; i < all_values.size(); ++i){
					if(fabs(all_values[i]) > max_abs_value) max_abs_value = all_values[i];
				}

				return max_abs_value;
		}

// Assembly:
pushq %rbx
subq $0x70, %rsp
movq %rsp, %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
callq 0x15770
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm4, %xmm4
xorl %edx, %edx
movapd 0x1c1e(%rip), %xmm0     # 0x1c2f0
cmpq %rdx, %rcx
je 0x1a702
movsd (%rax,%rdx,8), %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
movapd %xmm4, %xmm3
cmpltsd %xmm2, %xmm3
andpd %xmm3, %xmm1
andnpd %xmm4, %xmm3
orpd %xmm1, %xmm3
incq %rdx
movapd %xmm3, %xmm4
jmp 0x1a6d2
leaq 0x30(%rsp), %rdi
movapd %xmm4, 0x20(%rsp)
callq 0x1724a
leaq 0x50(%rsp), %rdi
callq 0x1724a
movq %rsp, %rdi
callq 0x1722c
movaps 0x20(%rsp), %xmm0
addq $0x70, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1724a
leaq 0x50(%rsp), %rdi
callq 0x1724a
movq %rsp, %rdi
callq 0x1722c
movq %rbx, %rdi
callq 0x2290