LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/joao18araujo[P]pierluigi/src/song_reader.cpp
// Function: SongReader::string_to_compass_time(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
CompassTime SongReader::string_to_compass_time(string line){
  if(!regex_match(line, regex("\\\\time \\d+\\/\\d+")))
    return CompassTime();

  int times, base_note;
  sscanf(line.c_str(), "\\time %d/%d\n", &times, &base_note);
  return CompassTime(times, base_note);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x1651f(%rip), %rsi     # 0x3b6af
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x26350
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x316eb
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x251dc
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5360
leaq 0x20(%rsp), %rdi
callq 0x263b8
testb %bpl, %bpl
je 0x25218
movq (%rbx), %rdi
leaq 0x164ca(%rip), %rsi     # 0x3b6bf
movq %rsp, %rbx
leaq 0x20(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x5330
movl (%rbx), %ecx
movl (%r14), %eax
shlq $0x20, %rax
orq %rcx, %rax
jmp 0x25222
movabsq $0x400000004, %rax      # imm = 0x400000004
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25244
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5360
leaq 0x20(%rsp), %rdi
callq 0x263b8
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonfonts/src/fonts.c
// Function: IsAvailable
static int IsAvailable(lua_State *L)
    {
    const char *name = luaL_checkstring(L, 1);
    font_t *font = font_search(L, name);
    lua_pushboolean(L, font !=NULL);
    return 1;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x10e0
movq %rax, %rdi
callq 0xed7a
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x1140
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonfonts/src/fonts.c
// Function: List
static int List(lua_State *L)
    {
    int i, byname;
    rec_t *rec;

    byname = optboolean(L, 1, 0);

    lua_newtable(L);

    if(byname)
        {
        rec = first(" ");
        while(rec)
            {
            lua_pushboolean(L, 1);
            lua_setfield(L, -2, (const char*)rec->name);
            rec = next(rec);
            }
        }
    else
        {
        i = 1;
        rec = first(" ");
        while(rec)
            {
            lua_pushstring(L, (const char*)rec->name);
            lua_seti(L, -2, i++);
            rec = next(rec);
            }
        }

    return 1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x11e0
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1090
callq 0x16ee
movq %rax, %r14
testl %ebp, %ebp
je 0xee4e
testq %r14, %r14
je 0xee8c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1140
movq 0x20(%r14), %rdx
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x10a0
movq %r14, %rdi
callq 0xf364
movq %rax, %r14
testq %rax, %rax
jne 0xee1e
jmp 0xee8c
testq %r14, %r14
je 0xee8c
movl $0x1, %r15d
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x11d0
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r15, %rdx
callq 0x10f0
movq %r14, %rdi
callq 0xf364
movq %rax, %r14
movq %r12, %r15
testq %rax, %rax
jne 0xee59
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonfonts/src/utils.c
// Function: moonfonts_Malloc
void *Malloc(lua_State *L, size_t size)
    {
    void *ptr = Malloc_(size);
    if(ptr==NULL)
        { luaL_error(L, errstring(ERR_MEMORY)); return NULL; }
    memset(ptr, 0, size);
    //DBG("Malloc %p\n", ptr);
    return ptr;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x182899e(%rip), %rax   # 0x1937118
testq %rax, %rax
je 0x10e7ab
movq %rsi, %r14
movq 0x1828997(%rip), %rdi   # 0x1937120
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq *%rax
testq %rax, %rax
je 0x10e7ab
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
leaq 0x181487c(%rip), %rsi   # 0x192302e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/stetre[P]moonfonts/src/utils.c
// Function: moonfonts_testboolean
int testboolean(lua_State *L, int arg, int *err)
    {
    if(!lua_isboolean(L, arg))
        { *err = ERR_TYPE; return 0; }
    *err = 0;
    return lua_toboolean(L, arg);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x11c0
cmpl $0x1, %eax
jne 0x10e8ee
movl $0x0, (%rbx)
movq %r14, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
movl $0xfffffffe, (%rbx)     # imm = 0xFFFFFFFE
xorl %eax, %eax
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>::empty() const
bool HierarchicalBlockSparseMatrix<Treal>::empty() const {
			if(nRows == 0 && nCols == 0 && submatrix.empty() && !children_exist())
			  return true;
			else
			  return false;
		}

// Assembly:
movl 0x4(%rdi), %eax
orl (%rdi), %eax
jne 0x4305
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
jne 0x4305
movq 0x58(%rdi), %xmm0
movq 0x48(%rdi), %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq 0x38(%rdi), %xmm0
movq 0x28(%rdi), %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
por %xmm1, %xmm2
pxor %xmm0, %xmm0
pcmpeqd %xmm2, %xmm0
movmskps %xmm0, %eax
xorl $0xf, %eax
je 0x4308
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::resize(int, int, unsigned long*)
void HierarchicalBlockSparseMatrix<Treal>::resize(int nRows_, int nCols_, size_t* no_of_resizes) {
		assert(blocksize > 0);

		if(!empty()) clear();

		nRows_orig = nRows_; // only top level contains true size, rest have duplicates of nRows and nCols
		nCols_orig = nCols_;

		// lowest level
		if(nRows_ <= blocksize && nCols_ <= blocksize){
			nRows = blocksize;
			nCols = blocksize;
			submatrix.resize(blocksize*blocksize);
			if(no_of_resizes != NULL) (*no_of_resizes)++;
			return;
		}

		// actually, matrix is always kept square, with padding with zeros where necessary
		// the "virtual dimension" can be computed as blocksize * 2^P,
		// where P is such that blocksize * 2^(P-1) <= max(nRows_, nCols_) <= blocksize * 2^P

		int maxdim = ((nRows_ > nCols_) ? nRows_ : nCols_);

		//how many times block covers maxdim
		int n_covers = maxdim / blocksize;
		if(maxdim % blocksize != 0) n_covers += 1;

		// now we need to find P such that 2^(P-1) <= n_covers <= 2^P
		int P = 1;
		int two_to_power_P = 2;
		while(n_covers >  two_to_power_P){
			two_to_power_P *= 2;
			P += 1;
		}

		int virtual_size = blocksize * two_to_power_P;


		nRows = virtual_size;
		nCols = virtual_size;

	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
jle 0x43a3
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x42c4
testb %al, %al
jne 0x4339
movq %rbx, %rdi
callq 0x43c2
movl %r15d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movl 0x10(%rbx), %esi
cmpl %r15d, %esi
setl %al
cmpl %ebp, %esi
setl %cl
orb %al, %cl
je 0x437c
cmpl %ebp, %r15d
cmovgl %r15d, %ebp
movl %ebp, %eax
cltd
idivl %esi
cmpl $0x1, %edx
sbbl $-0x1, %eax
movl $0x2, %edx
movl %edx, %ecx
leal (%rcx,%rcx), %edx
cmpl %ecx, %eax
jg 0x4369
imull %esi, %ecx
movl %ecx, (%rbx)
movl %ecx, 0x4(%rbx)
jmp 0x4398
movl %esi, (%rbx)
movl %esi, 0x4(%rbx)
addq $0x70, %rbx
imull %esi, %esi
movq %rbx, %rdi
callq 0x696e
testq %r14, %r14
je 0x4398
incq (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x61d5(%rip), %rdi      # 0xa57f
leaq 0x61dc(%rip), %rsi      # 0xa58d
leaq 0x624c(%rip), %rcx      # 0xa604
movl $0x221, %edx            # imm = 0x221
callq 0x20a0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::clear()
void HierarchicalBlockSparseMatrix<Treal>::clear() {

			if(empty()){
				return;
			}

			if(lowest_level()){
				submatrix.clear();
				nRows = 0;
				nCols = 0;
				if(children_exist()){
					throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::clear: children exist on leaf level.");
				}
				return;
			}

			for(int i = 0; i < 4; ++i){
				if(children[i] != NULL){
					children[i]->clear(); // smart pointer, no need to call delete explicitly!
					children[i] = NULL;
				}
			}
			nRows = 0;
			nCols = 0;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x42c4
testb %al, %al
jne 0x4496
movq %rbx, %rdi
callq 0x6b0e
testb %al, %al
je 0x4459
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x43f0
movq %rax, 0x78(%rbx)
movq $0x0, (%rbx)
movq 0x58(%rbx), %xmm0
movq 0x48(%rbx), %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq 0x38(%rbx), %xmm0
movq 0x28(%rbx), %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
por %xmm1, %xmm2
pxor %xmm0, %xmm0
pcmpeqd %xmm2, %xmm0
movmskps %xmm0, %eax
xorl $0xf, %eax
je 0x4496
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x6241(%rip), %rsi      # 0xa67c
movq %rax, %rdi
callq 0x2060
movq 0x9ba6(%rip), %rsi      # 0xdff0
movq 0x9b6f(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
movl $0x30, %r14d
movq -0x8(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x4485
callq 0x43c2
movq (%rbx,%r14), %rdi
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rbx,%r14)
testq %rdi, %rdi
je 0x4485
callq 0x6b3c
addq $0x10, %r14
cmpq $0x70, %r14
jne 0x445f
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_frob_squared() const
Treal HierarchicalBlockSparseMatrix<Treal>::get_frob_squared() const  {

			if(empty())
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_frob_squared: empty matrix occured.");

		    if(lowest_level()){

				Treal frob_squared = 0.0;
				for(int i = 0; i < submatrix.size(); ++i){
					frob_squared += submatrix[i] * submatrix[i];
				}
				return frob_squared;
			}
			else{

				Treal frob_squared = 0.0;

				for(int i = 0; i < 4; ++i){
					if(children[i] != NULL) frob_squared += children[i]->get_frob_squared();
				}

				return frob_squared;
			}

		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x42c4
testb %al, %al
jne 0x4548
movq %rbx, %rdi
callq 0x6b0e
testb %al, %al
je 0x4508
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
je 0x4538
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm1, %xmm1
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rdx
cmpq %rdx, %rcx
jne 0x44f1
jmp 0x453c
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x452c
movsd %xmm1, (%rsp)
callq 0x44b2
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
addq $0x10, %r14
cmpq $0x40, %r14
jne 0x450f
jmp 0x453c
xorpd %xmm1, %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x6174(%rip), %rsi      # 0xa6d0
movq %rax, %rdi
callq 0x2060
movq 0x9a85(%rip), %rsi      # 0xdff0
movq 0x9a4e(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_nnz() const
size_t HierarchicalBlockSparseMatrix<Treal>::get_nnz() const  {
			if(empty())
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_nnz: empty matrix occured.");

		    if(lowest_level()){

                //this seems to be more logical!
				int nnz = 0;
				for(int i = 0; i < submatrix.size(); ++i){
					if(fabs(submatrix[i]) > 0.0) nnz += 1;
				}
				return nnz;
			}
			else{

				int nnz = 0.0;

				for(int i = 0; i < 4; ++i){
					if(children[i] != NULL) nnz += children[i]->get_nnz();
				}

				return nnz;
			}

		}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x42c4
testb %al, %al
jne 0x460e
movq %rbx, %rdi
callq 0x6b0e
testb %al, %al
je 0x45e2
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
je 0x4604
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
xorl %esi, %esi
ucomisd (%rax,%rdx,8), %xmm0
setne %sil
addl %esi, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0x45cb
jmp 0x4606
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x45f8
callq 0x458e
addl %eax, %ebp
addq $0x10, %r14
cmpq $0x40, %r14
jne 0x45e7
jmp 0x4606
xorl %ebp, %ebp
movslq %ebp, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x648b(%rip), %rsi      # 0xaaad
movq %rax, %rdi
callq 0x2060
movq 0x99bf(%rip), %rsi      # 0xdff0
movq 0x9988(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_values(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, std::vector<double, std::allocator<double>>&) const
void HierarchicalBlockSparseMatrix<Treal>::get_values(const std::vector<int> & rows,
						  const std::vector<int> & cols,
						  std::vector<Treal> & values) const  {

			if(empty()){
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_values: empty matrix occured.");
			}

			if(rows.size() != cols.size()){
				throw std::runtime_error("Error in HierarchicalBlockSparseMatrix<Treal>::get_values: bad sizes.");
			}

			if(rows.size() == 0) return;

			values.resize(rows.size());

			for(int i = 0; i < rows.size(); ++i){
				values[i] = get_single_value(rows[i],cols[i]);
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x42c4
testb %al, %al
jne 0x46e4
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, %rsi
subq %rax, %rsi
movq 0x8(%r14), %rdx
subq (%r14), %rdx
cmpq %rdx, %rsi
jne 0x4702
cmpq %rax, %rcx
je 0x46da
sarq $0x2, %rsi
movq %rbx, %rdi
callq 0x696e
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x46da
xorl %r13d, %r13d
movl (%rax,%r13,4), %esi
movq (%r14), %rax
movl (%rax,%r13,4), %edx
movq %r12, %rdi
callq 0x80f2
movq (%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
ja 0x46a8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x6403(%rip), %rsi      # 0xaafb
movq %rax, %rdi
callq 0x2060
jmp 0x471e
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x6436(%rip), %rsi      # 0xab4c
movq %rax, %rdi
callq 0x2060
movq 0x98cb(%rip), %rsi      # 0xdff0
movq 0x9894(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
jmp 0x4736
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_size() const
size_t HierarchicalBlockSparseMatrix<Treal>::get_size() const  {
			if(empty()) return 5 * sizeof(int) + 4 * sizeof(size_t) + 1 * sizeof(Treal)  + 1 * sizeof(size_t);

			if(lowest_level()){
				return 5 * sizeof(int) + 4 * sizeof(size_t) + 1 * sizeof(Treal) + 1 * sizeof(size_t) + submatrix.size() * sizeof(Treal);
			}

			size_t totalsize = 5 * sizeof(int) + 4 * sizeof(size_t) + 1 * sizeof(Treal) + 1 * sizeof(size_t); // keep sizes of children in a row!


			if(children[0] != NULL){
				totalsize += children[0]->get_size();
			}


			if(children[1] != NULL) {
				totalsize += children[1]->get_size();
			}


			if(children[2] != NULL){
				totalsize += children[2]->get_size();
			}


			if(children[3] != NULL){
				totalsize += children[3]->get_size();
			}


			return totalsize;

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x42c4
testb %al, %al
je 0x51b9
movl $0x44, %r15d
xorl %ebx, %ebx
jmp 0x5232
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x6b0e
testb %al, %al
jne 0x5226
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x51de
callq 0x519e
movq %rax, %r15
addq $0x44, %r15
jmp 0x51e4
movl $0x44, %r15d
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x51f5
callq 0x519e
addq %rax, %r15
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x5206
callq 0x519e
addq %rax, %r15
movq 0x58(%r14), %r14
testq %r14, %r14
je 0x5232
addq %r15, %rbx
movq %r14, %rdi
callq 0x42c4
testb %al, %al
je 0x51bb
movl $0x44, %r15d
jmp 0x5232
movq 0x78(%r14), %r15
subq 0x70(%r14), %r15
addq $0x44, %r15
addq %r15, %rbx
movq %rbx, %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>::update_internal_info()
void HierarchicalBlockSparseMatrix<Treal>::update_internal_info() {

			if(empty()) return;

			frob_norm_squared_internal = 0.0;

			if(lowest_level()){

				frob_norm_squared_internal = get_frob_squared();

				return;
			}

			for(int i = 0; i < 4; ++i){
				if(children[i] != NULL){
					children[i]->update_internal_info();
					frob_norm_squared_internal += children[i]->frob_norm_squared_internal;
				}
			}


    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x42c4
testb %al, %al
jne 0x6137
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x6b0e
testb %al, %al
je 0x6107
movq %rbx, %rdi
callq 0x44b2
movsd %xmm0, 0x18(%rbx)
jmp 0x6137
xorl %r14d, %r14d
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x612d
callq 0x60d4
movq 0x28(%rbx,%r14), %rax
movsd 0x18(%rax), %xmm0
addsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x10, %r14
cmpq $0x40, %r14
jne 0x610a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_first_row_position() const
int HierarchicalBlockSparseMatrix<Treal>::get_first_row_position() const  {

            if(parent == NULL) return 0; // top level
            else{

               std::string position_code_str = get_position_code();
               int y0 = 0;
               int two_to_power = 1;

                for(int i = position_code_str.length()-1; i >= 0; --i){
                    char K = position_code_str[i];
                    if(K == '1' || K == '3'){
                        y0 += two_to_power;
                    }
                    two_to_power *= 2;
                }

                y0 *= nRows;
                return y0;
            }

		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x68(%rdi)
je 0x7b7f
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d60
movl 0x8(%rbx), %eax
decl %eax
movq (%rbx), %rdi
js 0x7b83
movl %eax, %eax
xorl %ebx, %ebx
movl $0x1, %ecx
movb (%rdi,%rax), %dl
andb $-0x3, %dl
cmpb $0x31, %dl
movl $0x0, %edx
cmovel %ecx, %edx
addl %edx, %ebx
addl %ecx, %ecx
addq $-0x1, %rax
jb 0x7b62
jmp 0x7b85
xorl %ebx, %ebx
jmp 0x7ba0
xorl %ebx, %ebx
imull (%r14), %ebx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7ba0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_first_col_position() const
int HierarchicalBlockSparseMatrix<Treal>::get_first_col_position() const  {

            if(parent == NULL) return 0; // top level
            else{

               std::string position_code_str = get_position_code();
               int x0 = 0;
               int two_to_power = 1;

                for(int i = position_code_str.length()-1; i >= 0; --i){
                    char K = position_code_str[i];
                    if(K == '2' || K == '3'){
                        x0 += two_to_power;
                    }
                    two_to_power *= 2;
                }

                x0 *= nCols;
                return x0;
            }

		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x68(%rdi)
je 0x7bfb
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d60
movl 0x8(%rbx), %eax
decl %eax
movq (%rbx), %rdi
js 0x7bff
movl %eax, %eax
xorl %ebx, %ebx
movl $0x1, %ecx
movb (%rdi,%rax), %dl
andb $-0x2, %dl
cmpb $0x32, %dl
movl $0x0, %edx
cmovel %ecx, %edx
addl %edx, %ebx
addl %ecx, %ecx
addq $-0x1, %rax
jb 0x7bde
jmp 0x7c01
xorl %ebx, %ebx
jmp 0x7c1d
xorl %ebx, %ebx
imull 0x4(%r14), %ebx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7c1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_position_code[abi:cxx11]() const
std::string HierarchicalBlockSparseMatrix<Treal>::get_position_code() const  {

            HierarchicalBlockSparseMatrix<Treal> *tmp = parent;

            if(parent != NULL){
                std::string code;
                if(this == parent->children[0].get()) code = "0";
                if(this == parent->children[1].get()) code = "1";
                if(this == parent->children[2].get()) code = "2";
                if(this == parent->children[3].get()) code = "3";
                return parent->get_position_code() + code;
            }
            else{
                return "";
            }

		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %rsi
testq %rsi, %rsi
je 0x7e62
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpq %r14, 0x28(%rsi)
jne 0x7db4
leaq 0x27ed(%rip), %rcx      # 0xa58b
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2180
movq 0x68(%r14), %rsi
cmpq %r14, 0x38(%rsi)
jne 0x7dd9
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x24ad(%rip), %rcx      # 0xa275
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2180
movq 0x68(%r14), %rsi
cmpq %r14, 0x48(%rsi)
jne 0x7dfe
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x2532(%rip), %rcx      # 0xa31f
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2180
movq 0x68(%r14), %rsi
cmpq %r14, 0x58(%rsi)
jne 0x7e23
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x2c45(%rip), %rcx      # 0xaa57
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2180
movq 0x68(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7d60
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x2040
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x7e7d
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x7e83
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x234b(%rip), %rdx      # 0xa1bb
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7f1c
jmp 0x7ecb
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7eb5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2140
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7ecb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7efd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x7efd
jmp 0x7efa
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7f13
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/./test_utils.h
// Function: SparseMatrix::to_full(std::vector<double, std::allocator<double>>&, unsigned int, unsigned int)
void to_full(std::vector<double> & fullMatrix, unsigned int nRows, unsigned int nCols) {
    fullMatrix.resize( nRows*nCols );
    for(unsigned int ind=0; ind<nRows*nCols; ind++)
      fullMatrix[ind] = 0;
    for(unsigned int ind=0; ind<rows.size(); ind++)
      fullMatrix[rows[ind]+nRows*cols[ind]] = values[ind];
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
imull %edx, %r12d
movq %rsi, %rdi
movq %r12, %rsi
callq 0x696e
testl %r12d, %r12d
je 0x8451
movq (%r14), %rdi
leaq (,%r12,8), %rdx
xorl %esi, %esi
callq 0x2090
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0x8492
sarq $0x2, %rcx
movq 0x18(%r15), %rdx
movq 0x30(%r15), %rsi
movq (%r14), %rdi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm0
movl (%rdx,%r8,4), %r9d
imull %ebx, %r9d
addl (%rax,%r8,4), %r9d
movsd %xmm0, (%rdi,%r9,8)
incq %r8
movl %r8d, %r9d
cmpq %r9, %rcx
ja 0x846f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2) {
  std::vector<double> row(2);
  row[0] = x1;
  row[1] = x2;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x2130
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x9152
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x897b
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8992
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x89b9
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x89b9
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x89d0
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2, double x3) {
  std::vector<double> row(3);
  row[0] = x1;
  row[1] = x2;
  row[2] = x3;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x18, %edi
callq 0x2130
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0x18(%rsp), %rdi
callq 0x9152
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8a62
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8a79
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8aa0
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8aa0
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8ab7
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2, double x3, double x4) {
  std::vector<double> row(4);
  row[0] = x1;
  row[1] = x2;
  row[2] = x3;
  row[3] = x4;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x20, %edi
callq 0x2130
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
leaq 0x28(%rsp), %rdi
callq 0x9152
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8b5c
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8b73
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8b9a
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8b9a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8bb1
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double, double, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2, double x3, double x4, double x5) {
  std::vector<double> row(5);
  row[0] = x1;
  row[1] = x2;
  row[2] = x3;
  row[3] = x4;
  row[4] = x5;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x28, %edi
callq 0x2130
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
leaq 0x28(%rsp), %rdi
callq 0x9152
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8c65
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8c7c
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8ca3
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8ca3
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8cba
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double, double, double, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2, double x3, double x4, double x5, double x6) {
  std::vector<double> row(6);
  row[0] = x1;
  row[1] = x2;
  row[2] = x3;
  row[3] = x4;
  row[4] = x5;
  row[5] = x6;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm5, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x30, %edi
callq 0x2130
leaq 0x50(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0x38(%rsp), %rdi
callq 0x9152
leaq 0x38(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8d81
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8d98
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8dbf
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8dbf
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8dd6
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double, double, double, double, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2, double x3, double x4, double x5, double x6, double x7) {
  std::vector<double> row(7);
  row[0] = x1;
  row[1] = x2;
  row[2] = x3;
  row[3] = x4;
  row[4] = x5;
  row[5] = x6;
  row[6] = x7;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movsd %xmm6, 0x30(%rsp)
movsd %xmm5, 0x28(%rsp)
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x38, %edi
callq 0x2130
leaq 0x50(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x38(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
leaq 0x38(%rsp), %rdi
callq 0x9152
leaq 0x38(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8eac
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8ec3
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8eea
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8eea
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8f01
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/test_utils.cc
// Function: set_row(SparseMatrix&, int, double, double, double, double, double, double, double, double)
void set_row(SparseMatrix & A, int rowIdx, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8) {
  std::vector<double> row(8);
  row[0] = x1;
  row[1] = x2;
  row[2] = x3;
  row[3] = x4;
  row[4] = x5;
  row[5] = x6;
  row[6] = x7;
  row[7] = x8;
  A.set_row(rowIdx, row);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movsd %xmm7, 0x40(%rsp)
movsd %xmm6, 0x38(%rsp)
movsd %xmm5, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
movl $0x40, %edi
callq 0x2130
leaq 0x60(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x40(%rax), %rcx
movq %rcx, 0x10(%rsi)
movq %rcx, 0x8(%rsi)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
leaq 0x48(%rsp), %rdi
callq 0x9152
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9048
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x8fea
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x9001
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9028
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x9028
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x903f
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/toxaart[P]hierarchical_block_sparse_lib/test_source/./test_utils.h
// Function: SparseMatrix::set_row(int, std::vector<double, std::allocator<double>>)
void set_row(int rowIdx, std::vector<double> row_values) {
    int size_new = rows.size()+row_values.size();
    rows.reserve(size_new);
    cols.reserve(size_new);
    values.reserve(size_new);
    for (size_t ind = 0; ind < row_values.size(); ind++) {
      rows.push_back(rowIdx);
      cols.push_back(ind);
      values.push_back(row_values[ind]);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, (%rsp)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rdx, %r14
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
shrq $0x2, %rax
shrq $0x3, %rcx
addl %eax, %ecx
movslq %ecx, %r13
movq %r13, %rsi
callq 0x7c28
leaq 0x18(%rbx), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x7c28
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x7cc4
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x9143
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x90c8
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x90d3
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x86e4
movl %ebp, 0x4(%rsp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x90ed
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x90fa
movq %r15, %rdi
leaq 0x4(%rsp), %rdx
callq 0x84e4
movq (%r14), %rax
leaq (%rax,%r13), %rdx
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x911d
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x9128
movq %r12, %rdi
callq 0x7fb2
movq (%r14), %rax
incq %rbp
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x8, %r13
cmpq %rcx, %rbp
jb 0x90af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: copyscript(Text*, unsigned char*)
void
copyscript(Text *t, uchar *s)
{
	do {
		assure(t, 2);
	} while((*t->w++ = *s++) != 0);
	if(--t->w > t->s && t->w[-1] != '\n') {
		*t->w++ = '\n';
		*t->w = 0;
	}
	safescript(t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rbx)
je 0x5757
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jb 0x5767
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a81
movq (%rbx), %rax
movb (%r14), %cl
incq %r14
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb %cl, (%rax)
testb %cl, %cl
jne 0x5740
movq (%rbx), %rdx
movq 0x10(%rbx), %rcx
leaq -0x1(%rdx), %rax
movq %rax, (%rbx)
cmpq %rcx, %rax
jbe 0x57a7
cmpb $0xa, -0x2(%rdx)
je 0x57a7
movq %rdx, (%rbx)
movb $0xa, -0x1(%rdx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rcx
cmpq %rcx, %rax
jbe 0x57b5
cmpb $0x5c, -0x2(%rax)
je 0x57bd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x78b2(%rip), %rdi      # 0xd076
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: readscript(Text*, char*)
void
readscript(Text *t, char *s)
{
	int n;
	FILE *f = aopen(s);
	for(;;) {
		assure(t, 4);
		n = fread(t->w, 1, t->e - t->w - 3, f);
		if(n <= 0)
			break;
		t->w += n;
	}
	fclose(f);
	if(t->w > t->s && t->w[-1] != '\n') {
		*t->w++ = '\n';
		warn("newline appended to script segment");
	}
	*t->w = 0;
	safescript(t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5b19
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x57fb
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
leaq -0x5(%rdx), %rax
cmpq %rax, %rdi
jb 0x580f
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a81
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rdi, %rdx
addq $-0x3, %rdx
movl $0x1, %esi
movq %r14, %rcx
callq 0x5270
testl %eax, %eax
jle 0x5831
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, (%rbx)
jmp 0x57e4
movq %r14, %rdi
callq 0x5160
movq (%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0x5848
cmpb $0xa, -0x1(%rax)
jne 0x5868
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rcx
cmpq %rcx, %rax
jbe 0x5860
cmpb $0x5c, -0x2(%rax)
je 0x5885
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0xa, (%rax)
leaq 0x7818(%rip), %rdi      # 0xd091
xorl %eax, %eax
callq 0x5320
movq (%rbx), %rax
jmp 0x5848
leaq 0x77ea(%rip), %rdi      # 0xd076
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5320
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: quit(char const*, ...)
void
quit(const char *format, ...)
{
	va_list args;
	fprintf(stderr,"sed error: ");
	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);
	fprintf(stderr,"\n");
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x58fd
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xd6d4(%rip), %r15      # 0x12fd8
movq (%r15), %rcx
leaq 0x77d4(%rip), %rdi      # 0xd0e2
movl $0xb, %esi
movl $0x1, %edx
callq 0x5300
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5220
movq (%r15), %rsi
movl $0xa, %edi
callq 0x51f0
movl $0x1, %edi
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: initinput(int, char**)
void
initinput(int argc, char **argv)
{
	input.iargc = argc;
	input.iargv = argv;
	if(input.iargc == 0) {
		input.iargc = 1;	/* for ateof() */
		input.ifile = stdin;
	} else
		input.ifile = aopen(*input.iargv);
}

// Assembly:
movl %edi, 0xddbb(%rip)      # 0x13720
movq %rsi, 0xddbc(%rip)      # 0x13728
testl %edi, %edi
je 0x597f
pushq %rax
movq (%rsi), %rdi
callq 0x5b19
addq $0x8, %rsp
jmp 0x5993
movl $0x1, 0xdd97(%rip)      # 0x13720
movq 0xd640(%rip), %rax      # 0x12fd0
movq (%rax), %rax
movq %rax, 0xdd96(%rip)      # 0x13730
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: readline(Text*)
int
readline(Text *t)
{
	int c;
	int len = t->w - t->s;
	coda();
	if(qflag || ateof())
		return 0;
	for(;;) {
		assure(t, 2);
		getch(&c);
		if(c == '\n')
			break;
		else if(c != EOF)
			*t->w++ = c;
		else if(t->w - t->s == len)
			return 0;
		else {
			warn("newline appended");
			break;
		}
	}
	*t->w = 0;			/* for safety */
	getch(&c);			/* to identify line $ */
	if(c != EOF)
		ungetc(c, input.ifile);
	recno++;
	sflag = 0;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
subq 0x10(%rdi), %r14
callq 0x7c0e
xorl %ebp, %ebp
cmpl $0x0, 0xdd29(%rip)      # 0x136e0
jne 0x5a7a
cmpl $0x0, 0xdd5c(%rip)      # 0x13720
jle 0x5a7a
cmpq $0x0, 0x10(%rbx)
je 0x59de
movq 0x8(%rbx), %rax
addq $-0x3, %rax
cmpq %rax, (%rbx)
jb 0x59eb
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a81
movq 0xdd3e(%rip), %rdi      # 0x13730
callq 0x50a0
cmpl $-0x1, %eax
jne 0x5a01
callq 0x5b4e
cmpl $-0x1, %eax
je 0x5a19
cmpl $0xa, %eax
je 0x5a36
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
jmp 0x59ca
movq (%rbx), %rax
subq 0x10(%rbx), %rax
movslq %r14d, %rcx
cmpq %rcx, %rax
je 0x5a7a
leaq 0x7685(%rip), %rdi      # 0xd0b4
xorl %eax, %eax
callq 0x5320
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0xdced(%rip), %rdi      # 0x13730
callq 0x50a0
cmpl $-0x1, %eax
jne 0x5a57
callq 0x5b4e
cmpl $-0x1, %eax
je 0x5a65
movq 0xdcd2(%rip), %rsi      # 0x13730
movl %eax, %edi
callq 0x5070
incl 0xdc6d(%rip)            # 0x136d8
movl $0x0, 0xdc6f(%rip)      # 0x136e4
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: grow(Text*, int)
void
grow(Text *t, int n)
{
	int w = t->w - t->s;
	int e = t->e - t->s + (n/BUFSIZ+1)*BUFSIZ;
	t->s = (uchar*)realloc(t->s, e);
	if(t->s == 0)
		quit("out of space");
	t->w = t->s + w;
	t->e = t->s + e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movl 0x8(%rdi), %eax
subl %r14d, %eax
leal 0x1fff(%rsi), %ecx
testl %esi, %esi
cmovnsl %esi, %ecx
movq (%rdi), %r12
andl $0xffffe000, %ecx       # imm = 0xFFFFE000
addl %ecx, %eax
addl $0x2000, %eax           # imm = 0x2000
movslq %eax, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x52a0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x5ae7
subl %r14d, %r12d
movslq %r12d, %rcx
addq %rax, %rcx
movq %rcx, (%rbx)
addq %rax, %r15
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x757b(%rip), %rdi      # 0xd069
xorl %eax, %eax
callq 0x589a
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: aopen(char*)
FILE *
aopen(char *s)
{
	FILE *f = fopen(s, "r");
	if(f == 0)
		quit("cannot open %s", s);
	return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x77ae(%rip), %rsi      # 0xd2d2
callq 0x51c0
testq %rax, %rax
je 0x5b30
popq %rbx
retq
leaq 0x758e(%rip), %rdi      # 0xd0c5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x589a
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: gopen()
int
gopen(void)
{
	int c = EOF;
	while(c==EOF && --input.iargc > 0) {
		fclose(input.ifile);
		input.ifile = aopen(*++input.iargv);
		c = getc(input.ifile);
	}
	return c;
}

// Assembly:
pushq %rax
movl 0xdbcb(%rip), %eax      # 0x13720
leal -0x1(%rax), %ecx
movl %ecx, 0xdbc2(%rip)      # 0x13720
cmpl $0x2, %eax
jl 0x5ba0
movq 0xdbc6(%rip), %rdi      # 0x13730
callq 0x5160
movq 0xdbb2(%rip), %rax      # 0x13728
leaq 0x8(%rax), %rcx
movq %rcx, 0xdba7(%rip)      # 0x13728
movq 0x8(%rax), %rdi
callq 0x5b19
movq %rax, 0xdb9f(%rip)      # 0x13730
movq %rax, %rdi
callq 0x50a0
cmpl $-0x1, %eax
je 0x5b4f
jmp 0x5ba5
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
nop