LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/joao18araujo[P]pierluigi/src/song_reader.cpp
// Function: SongReader::string_to_scale(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Scale SongReader::string_to_scale(string line){
  if(!regex_match(line, regex("\\\\key [a-g] \\\\(major|minor)")))
    return Scale();

  stringstream scale_line(line);
  string identificator, key, mode;
  scale_line >> identificator >> key >> mode;
  mode.erase(mode.begin());
  return Scale(key, mode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x11372(%rip), %rsi     # 0x296da
leaq 0x120(%rsp), %r15
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x18db8
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x18da0
movl %eax, %ebp
leaq 0x120(%rsp), %rdi
callq 0x18e1e
testb %bpl, %bpl
je 0x184ee
leaq 0x120(%rsp), %r15
pushq $0x18
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x5520
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xa8(%rsp), %rsi
movq %r15, %rdi
callq 0x5440
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x5440
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x5440
leaq 0x8(%rsp), %rdi
movq (%rdi), %rsi
callq 0x5410
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5480
leaq 0x1130f(%rip), %rsi     # 0x2974a
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96e6
leaq 0xc8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x12538
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5480
leaq 0xc8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x13c14
leaq 0x48(%rsp), %rdi
callq 0x51b0
leaq 0xc8(%rsp), %rdi
callq 0x979a
leaq 0x68(%rsp), %rdi
callq 0x51b0
leaq 0x88(%rsp), %rdi
callq 0x51b0
leaq 0x8(%rsp), %rdi
callq 0x51b0
leaq 0x28(%rsp), %rdi
callq 0x51b0
leaq 0xa8(%rsp), %rdi
callq 0x51b0
leaq 0x120(%rsp), %rdi
callq 0x52c0
jmp 0x184f6
movq %rbx, %rdi
callq 0x13934
movq %rbx, %rax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x51b0
jmp 0x18519
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x979a
jmp 0x1852b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x51b0
jmp 0x1853a
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x51b0
jmp 0x18560
jmp 0x1855d
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x18e1e
jmp 0x1858e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51b0
leaq 0x28(%rsp), %rdi
callq 0x51b0
leaq 0xa8(%rsp), %rdi
callq 0x51b0
leaq 0x120(%rsp), %rdi
callq 0x52c0
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rdi, %rbx
leaq 0x110c7(%rip), %rsi     # 0x296ff
leaq 0x10(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x18db8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x18da0
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x18e1e
testb %bpl, %bpl
je 0x18695
movq (%rbx), %rdi
leaq 0x1109f(%rip), %rsi     # 0x2970f
leaq 0x10(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x5340
movl (%rbx), %ecx
movl (%r14), %eax
shlq $0x20, %rax
orq %rcx, %rax
jmp 0x1869f
movabsq $0x400000004, %rax      # imm = 0x400000004
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x18e1e
movq %rbx, %rdi
callq 0x55d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/joao18araujo[P]pierluigi/src/song_reader.cpp
// Function: SongReader::song_clef_to_string[abi:cxx11](Song&)
string SongReader::song_clef_to_string(Song & song) {
  int total_midi = 0, total_notes = 0;
  for(auto note : song.notes) {
    if(not note.rest()) {
      total_midi += note.midi_number;
      total_notes++;
    }
  }

  Note treble("b", "", 4);
  Note bass("d", "", 3);

  double mid = total_notes ? (1.0 * total_midi) / total_notes : 0;
  string clef;
  if(treble.midi_number - mid <= mid - bass.midi_number)
    clef = "treble";
  else
    clef = "bass";

  return "\\clef " + clef;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rdi, %rbx
movq (%rsi), %r14
movq 0x8(%rsi), %r13
xorl %ebp, %ebp
leaq 0xa8(%rsp), %r15
xorl %r12d, %r12d
cmpq %r13, %r14
je 0x18801
movq %r15, %rdi
movq %r14, %rsi
callq 0x12676
movq %r15, %rdi
callq 0x1302a
xorl %ecx, %ecx
testb %al, %al
jne 0x187e9
movl 0xf4(%rsp), %ecx
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
addl %ecx, %r12d
movq %r15, %rdi
callq 0x979a
addq $0x58, %r14
jmp 0x187c4
leaq 0x11548(%rip), %rsi     # 0x29d50
leaq 0x88(%rsp), %rdi
leaq 0x100(%rsp), %rdx
callq 0x96e6
leaq 0x10f26(%rip), %rsi     # 0x2974a
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x96e6
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
pushq $0x4
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x12538
leaq 0x68(%rsp), %rdi
callq 0x51b0
leaq 0x88(%rsp), %rdi
callq 0x51b0
leaq 0x114e6(%rip), %rsi     # 0x29d5a
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x96e6
leaq 0x10ec0(%rip), %rsi     # 0x2974a
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x96e6
leaq 0x100(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
pushq $0x3
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x12538
leaq 0x28(%rsp), %rdi
callq 0x51b0
leaq 0x48(%rsp), %rdi
callq 0x51b0
xorpd %xmm0, %xmm0
testl %ebp, %ebp
je 0x188e2
cvtsi2sd %r12d, %xmm0
cvtsi2sd %ebp, %xmm1
divsd %xmm1, %xmm0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cvtsi2sdl 0xf4(%rsp), %xmm1
cvtsi2sdl 0x14c(%rsp), %xmm2
subsd %xmm0, %xmm1
subsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
leaq 0x10e0d(%rip), %rax     # 0x29725
leaq 0x10dff(%rip), %rsi     # 0x2971e
cmovbq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x5630
leaq 0x10df6(%rip), %rsi     # 0x2972a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x115e5
leaq 0x8(%rsp), %rdi
callq 0x51b0
leaq 0x100(%rsp), %rdi
callq 0x979a
leaq 0xa8(%rsp), %rdi
callq 0x979a
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x51b0
jmp 0x1898c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x51b0
jmp 0x189df
jmp 0x189dc
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x51b0
jmp 0x189ac
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x51b0
jmp 0x189ec
movq %rax, %rbx
jmp 0x189ec
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51b0
leaq 0x100(%rsp), %rdi
callq 0x979a
jmp 0x189df
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x979a
movq %rbx, %rdi
callq 0x55d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl %ebp, %esi
xorl %edx, %edx
callq 0x10e0
movq %rax, %rdi
callq 0xdaf4
xorl %esi, %esi
testq %rax, %rax
setne %sil
movq %rbx, %rdi
callq 0x1140
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x11e0
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1090
callq 0x16a6
movq %rax, %r14
testl %ebp, %ebp
je 0xd65e
pushq $0x1
popq %rbp
pushq $-0x2
popq %r15
testq %r14, %r14
je 0xd697
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1140
movq 0x20(%r14), %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x10a0
movq %r14, %rdi
callq 0xdb07
movq %rax, %r14
jmp 0xd633
pushq $0x1
popq %r15
pushq $-0x2
popq %rbp
testq %r14, %r14
je 0xd697
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x11d0
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x10f0
movq %r14, %rdi
callq 0xdb07
movq %rax, %r14
movq %r12, %r15
jmp 0xd665
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xa06cd
movq %rax, %rbx
testq %rax, %rax
je 0xa06b3
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x10b0
leaq 0x1814924(%rip), %rsi   # 0x18b4fde
movq %r14, %rdi
xorl %eax, %eax
callq 0x1170
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa07fb
andl $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_O2/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 0x39e0
movq 0x70(%rdi), %rax
cmpq 0x78(%rdi), %rax
jne 0x39e0
pushq %rax
callq 0x3d28
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
leaq 0x8(%rsp), %rsp
je 0x39e2
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a79
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x39bc
testb %al, %al
jne 0x3a11
movq %rbx, %rdi
callq 0x3ad0
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 0x3a52
cmpl %ebp, %r15d
cmovgl %r15d, %ebp
movl %ebp, %eax
cltd
idivl %esi
cmpl $0x1, %edx
sbbl $-0x1, %eax
pushq $0x2
popq %rdx
movl %edx, %ecx
leal (%rcx,%rcx), %edx
cmpl %ecx, %eax
jg 0x3a3f
imull %esi, %ecx
movl %ecx, (%rbx)
movl %ecx, 0x4(%rbx)
jmp 0x3a6e
movl %esi, (%rbx)
movl %esi, 0x4(%rbx)
addq $0x70, %rbx
imull %esi, %esi
movq %rbx, %rdi
callq 0x57fc
testq %r14, %r14
je 0x3a6e
incq (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4aff(%rip), %rdi      # 0x857f
leaq 0x4b06(%rip), %rsi      # 0x858d
leaq 0x4b76(%rip), %rcx      # 0x8604
movl $0x221, %edx            # imm = 0x221
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x39bc
testb %al, %al
jne 0x3b8f
movq %rbx, %rdi
callq 0x5a0a
testb %al, %al
je 0x3b47
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x3b07
movq %rax, 0x78(%rbx)
andq $0x0, (%rbx)
movq %rbx, %rdi
callq 0x3d28
testb %al, %al
je 0x3b8f
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x4b53(%rip), %rsi      # 0x867c
movq %rax, %rdi
callq 0x2050
movq 0x94b8(%rip), %rsi      # 0xcff0
movq 0x9481(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x21d0
pushq $0x28
popq %r13
leaq 0x8(%rsp), %r14
movq %rsp, %r15
cmpq $0x68, %r13
je 0x3b8b
movq (%rbx,%r13), %rdi
testq %rdi, %rdi
je 0x3b85
leaq (%rbx,%r13), %r12
callq 0x3ad0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5a26
movq %r14, %rdi
callq 0x5a54
addq $0x10, %r13
jmp 0x3b53
andq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39bc
testb %al, %al
jne 0x3c34
movq %rbx, %rdi
callq 0x5a0a
testb %al, %al
je 0x3bf8
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm1, %xmm1
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x3c28
movsd (%rax,%rdx,8), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm0, %xmm1
incq %rdx
jmp 0x3be1
xorpd %xmm1, %xmm1
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x3c28
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3c22
movsd %xmm1, (%rsp)
callq 0x3bb0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
addq $0x10, %r14
jmp 0x3bff
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x4a8a(%rip), %rsi      # 0x86d0
movq %rax, %rdi
callq 0x2050
movq 0x939b(%rip), %rsi      # 0xcff0
movq 0x9364(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39bc
testb %al, %al
jne 0x3dbc
movq %rbx, %rdi
callq 0x5a0a
testb %al, %al
je 0x3d92
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorl %edx, %edx
xorpd %xmm0, %xmm0
xorl %ebp, %ebp
cmpq %rdx, %rcx
je 0x3db4
xorl %esi, %esi
ucomisd (%rax,%rdx,8), %xmm0
setne %sil
addl %esi, %ebp
incq %rdx
jmp 0x3d7b
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq $0x40, %r14
je 0x3db4
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3dae
callq 0x3d48
addl %eax, %ebp
addq $0x10, %r14
jmp 0x3d97
movslq %ebp, %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x4cdf(%rip), %rsi      # 0x8aad
movq %rax, %rdi
callq 0x2050
movq 0x9213(%rip), %rsi      # 0xcff0
movq 0x91dc(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39bc
testb %al, %al
jne 0x3e89
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, %rsi
subq %rax, %rsi
movq 0x8(%r14), %rdx
subq (%r14), %rdx
cmpq %rdx, %rsi
jne 0x3ea5
cmpq %rax, %rcx
je 0x3e7f
sarq $0x2, %rsi
movq %rbx, %rdi
callq 0x57fc
xorl %r13d, %r13d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x3e7f
movl (%rax,%r13,4), %esi
movq (%r14), %rax
movl (%rax,%r13,4), %edx
movq %r12, %rdi
callq 0x6d42
movq (%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0x3e4b
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x4c60(%rip), %rsi      # 0x8afb
movq %rax, %rdi
callq 0x2050
jmp 0x3ebf
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x4c95(%rip), %rsi      # 0x8b4c
movq %rax, %rdi
callq 0x2050
movq 0x912a(%rip), %rsi      # 0xcff0
movq 0x90f3(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x21d0
jmp 0x3ed7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x44
popq %rbx
movq %r14, %rdi
callq 0x39bc
testb %al, %al
jne 0x46ea
movq %r14, %rdi
callq 0x5a0a
testb %al, %al
jne 0x46d9
movq 0x28(%r14), %rdi
movq %rbx, %r15
testq %rdi, %rdi
je 0x46a9
callq 0x4668
movq %rax, %r15
addq $0x44, %r15
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x46ba
callq 0x4668
addq %rax, %r15
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x46cb
callq 0x4668
addq %rax, %r15
movq 0x58(%r14), %r14
testq %r14, %r14
je 0x46e7
addq %r15, %r12
jmp 0x4679
movq 0x78(%r14), %rbx
subq 0x70(%r14), %rbx
addq $0x44, %rbx
jmp 0x46ea
movq %r15, %rbx
addq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::copy(hbsm::HierarchicalBlockSparseMatrix<double> const&, unsigned long*)
void HierarchicalBlockSparseMatrix<Treal>::copy(const HierarchicalBlockSparseMatrix<Treal> &other, size_t* no_of_resizes) {

			if(this == &other) return; // no need to copy itself to itself

			if(other.empty()){
				this->clear();
				return;
			}

			if(!empty()) clear();

			set_params(other.get_params());
			resize(other.nRows,other.nCols, no_of_resizes);
			nRows_orig = other.nRows_orig;
			nCols_orig = other.nCols_orig;


			if(other.lowest_level()){
				memcpy(&submatrix[0], &(other.submatrix[0]), sizeof(Treal) * other.submatrix.size());
				return;
			}

			frob_norm_squared_internal = other.frob_norm_squared_internal;
			n_block_multiplies = other.n_block_multiplies;

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

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


			}


		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %rsi, %rdi
je 0x5142
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x39bc
testb %al, %al
je 0x50e4
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ad0
movq %r14, %rdi
callq 0x39bc
testb %al, %al
jne 0x50f8
movq %r14, %rdi
callq 0x3ad0
movl 0x10(%rbx), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x3958
movl (%rbx), %esi
movl 0x4(%rbx), %edx
movq %r14, %rdi
movq %r15, %rcx
callq 0x39e4
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x5a0a
testb %al, %al
je 0x5151
movq 0x70(%r14), %rdi
movq 0x70(%rbx), %rsi
movq 0x78(%rbx), %rdx
subq %rsi, %rdx
callq 0x2120
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x18(%r14)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
pushq $0x28
popq %r12
leaq 0x8(%rsp), %r13
cmpq $0x68, %r12
je 0x5142
cmpq $0x0, (%r14,%r12)
jne 0x51c0
cmpq $0x0, (%rbx,%r12)
je 0x51ba
leaq (%r14,%r12), %rbp
movq %r13, %rdi
callq 0x68de
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5a26
leaq 0x10(%rsp), %rdi
callq 0x5a54
movq (%r14,%r12), %rdi
movq (%rbx,%r12), %rsi
movq %r15, %rdx
callq 0x50a2
movq (%r14,%r12), %rax
movq %r14, 0x68(%rax)
addq $0x10, %r12
jmp 0x516d
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x3f4c(%rip), %rsi      # 0x911e
movq %rax, %rdi
callq 0x2050
movq 0x7e0f(%rip), %rsi      # 0xcff0
movq 0x7dd8(%rip), %rdx      # 0xcfc0
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x39bc
testb %al, %al
jne 0x5232
andq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x5a0a
testb %al, %al
je 0x523a
movq %rbx, %rdi
callq 0x3bb0
movsd %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x5232
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x5266
callq 0x5204
movq 0x28(%rbx,%r14), %rax
movsd 0x18(%rax), %xmm0
addsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x10, %r14
jmp 0x523d
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x68(%rdi)
je 0x670f
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68fa
movl 0x8(%r14), %eax
movq (%r14), %rcx
decq %rax
pushq $0x1
popq %rdx
xorl %ebp, %ebp
testl %eax, %eax
js 0x6702
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movb (%rcx,%rsi), %sil
andb $-0x3, %sil
cmpb $0x31, %sil
movl $0x0, %esi
cmovel %edx, %esi
addl %esi, %ebp
addl %edx, %edx
decq %rax
jmp 0x66d9
imull (%rbx), %ebp
movq %rsp, %rdi
callq 0x2080
jmp 0x6711
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, 0x68(%rdi)
je 0x6782
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x68fa
movl 0x8(%r14), %eax
movq (%r14), %rcx
decq %rax
pushq $0x1
popq %rdx
xorl %ebp, %ebp
testl %eax, %eax
js 0x6774
movl %eax, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movb (%rcx,%rsi), %sil
andb $-0x2, %sil
cmpb $0x32, %sil
movl $0x0, %esi
cmovel %edx, %esi
addl %esi, %ebp
addl %edx, %edx
decq %rax
jmp 0x674b
imull 0x4(%rbx), %ebp
movq %rsp, %rdi
callq 0x2080
jmp 0x6784
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %rsi
testq %rsi, %rsi
je 0x69c3
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpq %r14, 0x28(%rsi)
jne 0x6940
leaq 0x1c59(%rip), %rsi      # 0x858b
leaq 0x8(%rsp), %rdi
callq 0x2210
movq 0x68(%r14), %rsi
cmpq %r14, 0x38(%rsi)
jne 0x695b
leaq 0x1928(%rip), %rsi      # 0x8275
leaq 0x8(%rsp), %rdi
callq 0x2210
movq 0x68(%r14), %rsi
cmpq %r14, 0x48(%rsi)
jne 0x6976
leaq 0x19b7(%rip), %rsi      # 0x831f
leaq 0x8(%rsp), %rdi
callq 0x2210
movq 0x68(%r14), %rsi
cmpq %r14, 0x58(%rsi)
jne 0x6991
leaq 0x20d4(%rip), %rsi      # 0x8a57
leaq 0x8(%rsp), %rdi
callq 0x2210
movq 0x68(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x68fa
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6a08
leaq 0x28(%rsp), %rdi
callq 0x2080
leaq 0x8(%rsp), %rdi
callq 0x2080
jmp 0x69d7
leaq 0x17f1(%rip), %rsi      # 0x81bb
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2080
jmp 0x69f6
jmp 0x69f3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x57fc
movq (%r14), %rax
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x7146
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x7137
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movq 0x30(%r15), %rdx
movq 0x18(%r15), %rsi
movq (%r14), %rdi
xorl %r8d, %r8d
movl %r8d, %r8d
cmpq %r8, %rcx
jbe 0x7187
movsd (%rdx,%r8,8), %xmm0
movl (%rsi,%r8,4), %r9d
imull %ebx, %r9d
addl (%rax,%r8,4), %r9d
movsd %xmm0, (%rdi,%r9,8)
incl %r8d
jmp 0x7162
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x38(%rsp), %r15
pushq $0x2
popq %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x20(%rsp), %rdi
callq 0x5c00
leaq 0x38(%rsp), %rdi
callq 0x5c00
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5c00
jmp 0x766b
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x38(%rsp), %r15
pushq $0x3
popq %rsi
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x20(%rsp), %rdi
callq 0x5c00
leaq 0x38(%rsp), %rdi
callq 0x5c00
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5c00
jmp 0x7721
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movsd %xmm3, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x48(%rsp), %r15
pushq $0x4
popq %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x30(%rsp), %rdi
callq 0x5c00
leaq 0x48(%rsp), %rdi
callq 0x5c00
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5c00
jmp 0x77e8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %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
leaq 0x48(%rsp), %r15
pushq $0x5
popq %rsi
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
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)
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x30(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x30(%rsp), %rdi
callq 0x5c00
leaq 0x48(%rsp), %rdi
callq 0x5c00
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5c00
jmp 0x78c0
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movsd %xmm5, 0x38(%rsp)
movsd %xmm4, 0x30(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x58(%rsp), %r15
pushq $0x6
popq %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x40(%rsp), %rdi
callq 0x5c00
leaq 0x58(%rsp), %rdi
callq 0x5c00
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5c00
jmp 0x79a9
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x70, %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
leaq 0x58(%rsp), %r15
pushq $0x7
popq %rsi
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
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)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x40(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x40(%rsp), %rdi
callq 0x5c00
leaq 0x58(%rsp), %rdi
callq 0x5c00
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5c00
jmp 0x7aa3
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movsd %xmm7, 0x48(%rsp)
movsd %xmm6, 0x40(%rsp)
movsd %xmm5, 0x38(%rsp)
movsd %xmm4, 0x30(%rsp)
movsd %xmm3, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0x68(%rsp), %r15
pushq $0x8
popq %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x3cca
movq (%r15), %rax
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x7c76
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x7bc6
leaq 0x50(%rsp), %rdi
callq 0x5c00
leaq 0x68(%rsp), %rdi
callq 0x5c00
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x5c00
jmp 0x7bb4
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5c00
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq %rdx, %r15
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
shrq $0x2, %rax
shrq $0x3, %rcx
addl %eax, %ecx
movslq %ecx, %rbp
movq %rbp, %rsi
callq 0x6790
leaq 0x18(%rbx), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0x6790
leaq 0x30(%rbx), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6826
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x8(%r15), %rax
subq (%r15), %rax
sarq $0x3, %rax
cmpq %rax, %rbp
jae 0x7c66
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
callq 0x52ae
movl %ebp, (%rsp)
movq %r12, %rdi
movq %rsp, %rsi
callq 0x71b4
movq (%r15), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x68bc
incq %rbp
addq $0x8, %r14
jmp 0x7c24
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: main
int
main(int argc, char **argv)
{
	static Text script;
	static Text data;
	for(;;) {
		switch(getopt(argc, argv, "bnf:e:")) {
		case 'b':
			bflag++;
			continue;
		case 'e':
			copyscript(&data, (uchar*)optarg);
			continue;
		case 'f':
			readscript(&data, optarg);
			continue;
		case 'n':
			nflag++;
			continue;
		case '?':
			quit("usage: sed [-n] script [files]\n"
			"     sed [-n] [-f scriptfile] "
			      "[-e script] [files]");
		case -1:
			break;
		}
		break;
	}
	if(data.s == 0) {
		if(optind >= argc)
			quit("no script");
		copyscript(&data, (uchar*)argv[optind++]);
	}
	if(ustrncmp(data.s, "#n", 2) == 0)
		nflag = 1;
	copyscript(&data, (uchar*)"\n\n");  /* e.g. s/a/\ */
	compile(&script, &data);
	// printscript(&script); //  debugging

	initinput(argc-optind, argv+optind);
	for(;;) {
		data.w = data.s;
		if(!readline(&data))
			break;
		execute(&script, &data);
	}
	if(fclose(stdout) == EOF)
		quit(stdouterr);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x6be3(%rip), %r15      # 0xc004
movq 0xcb98(%rip), %r13      # 0x11fc0
leaq 0xd2d9(%rip), %r12      # 0x12708
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5080
cmpl $0x62, %eax
je 0x5458
cmpl $0x65, %eax
je 0x546e
cmpl $0x66, %eax
je 0x5460
cmpl $0x6e, %eax
jne 0x547c
incl 0xd286(%rip)            # 0x126dc
jmp 0x542f
incl 0xd28a(%rip)            # 0x126e8
jmp 0x542f
movq (%r13), %rsi
movq %r12, %rdi
callq 0x55f0
jmp 0x542f
movq (%r13), %rsi
movq %r12, %rdi
callq 0x557d
jmp 0x542f
cmpl $0x3f, %eax
je 0x555a
movq 0xd28c(%rip), %rax      # 0x12718
testq %rax, %rax
jne 0x54bf
movq 0xcb48(%rip), %rax      # 0x11fe0
movslq (%rax), %rcx
cmpl %ebx, %ecx
jge 0x5574
leal 0x1(%rcx), %edx
movl %edx, (%rax)
movq (%r14,%rcx,8), %rsi
leaq 0xd255(%rip), %rdi      # 0x12708
callq 0x557d
movq 0xd259(%rip), %rax      # 0x12718
cmpb $0x23, (%rax)
jne 0x54d4
cmpb $0x6e, 0x1(%rax)
jne 0x54d4
movl $0x1, 0xd208(%rip)      # 0x126dc
leaq 0xd22d(%rip), %r15      # 0x12708
leaq 0x6b84(%rip), %rsi      # 0xc066
movq %r15, %rdi
callq 0x557d
leaq 0xd1ff(%rip), %r12      # 0x126f0
movq %r12, %rdi
movq %r15, %rsi
callq 0x5a60
movq 0xcadd(%rip), %rax      # 0x11fe0
movslq (%rax), %rax
subl %eax, %ebx
leaq (%r14,%rax,8), %rsi
movl %ebx, %edi
callq 0x5758
movq 0xd1fe(%rip), %rax      # 0x12718
movq %rax, 0xd1e7(%rip)      # 0x12708
movq %r15, %rdi
callq 0x5794
testl %eax, %eax
je 0x553a
movq %r12, %rdi
movq %r15, %rsi
callq 0x6885
jmp 0x5513
movq 0xca6f(%rip), %rax      # 0x11fb0
movq (%rax), %rdi
callq 0x5160
cmpl $-0x1, %eax
je 0x5568
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6aaa(%rip), %rdi      # 0xc00b
xorl %eax, %eax
callq 0x569b
leaq 0xcd31(%rip), %rax      # 0x122a0
movq (%rax), %rdi
jmp 0x5561
leaq 0x6ae1(%rip), %rdi      # 0xc05c
jmp 0x5561
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x2
popq %rbp
cmpq $0x0, 0x10(%rbx)
je 0x55a1
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jb 0x55ae
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5880
movq (%rbx), %rax
movb (%r14), %cl
incq %r14
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb %cl, (%rax)
testb %cl, %cl
jne 0x558a
movq (%rbx), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%rbx)
cmpq 0x10(%rbx), %rcx
jbe 0x55e4
cmpb $0xa, -0x2(%rax)
je 0x55e4
movq %rax, (%rbx)
movb $0xa, -0x1(%rax)
movq (%rbx), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x58ed