LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4338
testb %al, %al
jne 0x4730
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, %rsi
subq %rax, %rsi
movq 0x8(%r14), %rdx
subq (%r14), %rdx
cmpq %rdx, %rsi
jne 0x474e
cmpq %rax, %rcx
je 0x4726
sarq $0x2, %rsi
movq %rbx, %rdi
callq 0x699c
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x4726
xorl %r13d, %r13d
movl (%rax,%r13,4), %esi
movq (%r14), %rax
movl (%rax,%r13,4), %edx
movq %r12, %rdi
callq 0x8122
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 0x46f4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x639f(%rip), %rsi      # 0xaae3
movq %rax, %rdi
callq 0x2060
jmp 0x476a
movl $0x10, %edi
callq 0x2070
movq %rax, %rbx
leaq 0x63d2(%rip), %rsi      # 0xab34
movq %rax, %rdi
callq 0x2060
movq 0x987f(%rip), %rsi      # 0xdff0
movq 0x9848(%rip), %rdx      # 0xdfc0
movq %rbx, %rdi
callq 0x21a0
jmp 0x4782
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x4338
testb %al, %al
jne 0x5263
movq %r14, %rdi
callq 0x6b36
testb %al, %al
jne 0x526b
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x522d
callq 0x51f4
movq %rax, %r15
addq $0x44, %r15
jmp 0x5233
movl $0x44, %r15d
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x5244
callq 0x51f4
addq %rax, %r15
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x5255
callq 0x51f4
addq %rax, %r15
movq 0x58(%r14), %r14
testq %r14, %r14
je 0x5277
addq %r15, %rbx
jmp 0x51fe
movl $0x44, %r15d
jmp 0x5277
movq 0x78(%r14), %r15
subq 0x70(%r14), %r15
addq $0x44, %r15
addq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4338
testb %al, %al
jne 0x6177
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x6b36
testb %al, %al
je 0x6147
movq %rbx, %rdi
callq 0x44fe
movsd %xmm0, 0x18(%rbx)
jmp 0x6177
xorl %r14d, %r14d
movq 0x28(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x616d
callq 0x6114
movq 0x28(%rbx,%r14), %rax
movsd 0x18(%rax), %xmm0
addsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x18(%rbx)
addq $0x10, %r14
cmpq $0x40, %r14
jne 0x614a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ba3
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d88
movl 0x8(%rbx), %ecx
decl %ecx
js 0x7ba7
movq 0x8(%rsp), %rax
movl %ecx, %ecx
incq %rcx
xorl %ebx, %ebx
movl $0x1, %edx
movb -0x1(%rax,%rcx), %sil
andb $-0x3, %sil
cmpb $0x31, %sil
movl $0x0, %esi
cmovel %edx, %esi
addl %esi, %ebx
addl %edx, %edx
decq %rcx
jg 0x7b83
jmp 0x7ba9
xorl %ebx, %ebx
jmp 0x7bc8
xorl %ebx, %ebx
imull (%r14), %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7bc8
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_O1/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 0x7c2b
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d88
movl 0x8(%rbx), %ecx
decl %ecx
js 0x7c2f
movq 0x8(%rsp), %rax
movl %ecx, %ecx
incq %rcx
xorl %ebx, %ebx
movl $0x1, %edx
movb -0x1(%rax,%rcx), %sil
andb $-0x2, %sil
cmpb $0x32, %sil
movl $0x0, %esi
cmovel %edx, %esi
addl %esi, %ebx
addl %edx, %edx
decq %rcx
jg 0x7c0b
jmp 0x7c31
xorl %ebx, %ebx
jmp 0x7c51
xorl %ebx, %ebx
imull 0x4(%r14), %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7c51
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_O1/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 %rdi, %rbx
movq 0x68(%rsi), %rax
testq %rax, %rax
je 0x7e8a
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
cmpq %rsi, 0x28(%rax)
jne 0x7dd8
leaq 0x27ad(%rip), %rcx      # 0xa573
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2180
movq 0x68(%r14), %rax
cmpq %r14, 0x38(%rax)
jne 0x7dfd
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x246d(%rip), %rcx      # 0xa25d
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2180
movq 0x68(%r14), %rax
cmpq %r14, 0x48(%rax)
jne 0x7e22
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x24f2(%rip), %rcx      # 0xa307
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2180
movq 0x68(%r14), %rax
cmpq %r14, 0x58(%rax)
jne 0x7e47
movq %rsp, %rdi
movq 0x8(%rdi), %rdx
leaq 0x2c05(%rip), %rcx      # 0xaa3f
movl $0x1, %r8d
xorl %esi, %esi
callq 0x2180
movq 0x68(%r14), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7d88
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 0x7ea5
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x7eab
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x230b(%rip), %rdx      # 0xa1a3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7f44
jmp 0x7ef3
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 0x7edd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2140
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7ef3
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 0x7f25
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x7f25
jmp 0x7f22
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7f3b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x699c
testl %r12d, %r12d
je 0x8494
movq (%r14), %rdi
movl %r12d, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2090
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
je 0x84d5
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 0x84b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0x10, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x10(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rcx, 0x8(%r15)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x92ac
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x89d9
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x89f0
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8a19
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8a19
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8a30
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
movl $0x18, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, 0x10(%rax)
movq %rcx, 0x8(%r15)
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
movq %r15, %rsi
callq 0x92ac
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8ae5
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8afc
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8b27
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8b27
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x8b3e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0x20, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %rcx, 0x8(%r15)
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
movq %r15, %rsi
callq 0x92ac
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8c05
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8c1c
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8c45
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8c45
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8c5c
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
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
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r15
movaps %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
movl $0x28, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x28(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq %r12, 0x20(%rax)
movq %rcx, 0x8(%r15)
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
movq %r15, %rsi
callq 0x92ac
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8d37
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8d4e
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x8d79
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8d79
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x8d90
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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, 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
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0x30, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x30(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rcx, 0x8(%r15)
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
movq %r15, %rsi
callq 0x92ac
leaq 0x38(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8e7d
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8e94
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8ebd
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x8ebd
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8ed4
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
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
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r15
movaps %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
movl $0x38, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x38(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %r12, 0x30(%rax)
movq %rcx, 0x8(%r15)
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
movq %r15, %rsi
callq 0x92ac
leaq 0x38(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x8fd5
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x8fec
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x9017
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x9017
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x902e
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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, 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
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movl $0x40, %edi
callq 0x2130
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x40(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq %rcx, 0x8(%r15)
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
movq %r15, %rsi
callq 0x92ac
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x91a6
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9144
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x915b
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9187
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
jmp 0x9187
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x919e
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c5c
leaq 0x18(%rbx), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x7c5c
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x7cf2
movq 0x8(%r14), %rax
cmpq (%r14), %rax
je 0x929d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x9226
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x9231
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x8728
movl %ebp, 0x4(%rsp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x924b
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x9258
movq %r15, %rdi
leaq 0x4(%rsp), %rdx
callq 0x8528
movq (%r14), %rdx
addq %r13, %rdx
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x927a
movsd (%rdx), %xmm0
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x38(%rbx)
jmp 0x9282
movq %r12, %rdi
callq 0x7fd4
movq 0x8(%r14), %rax
subq (%r14), %rax
incq %rbp
sarq $0x3, %rax
addq $0x8, %r13
cmpq %rax, %rbp
jb 0x920d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: warn(char const*, ...)
void
warn(const char *format, ...)
{
	va_list args;
	fprintf(stderr,"sed warning: ");
	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);
	fprintf(stderr,"\n");
}

// 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 0x5383
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 0xdc4e(%rip), %r15      # 0x12fd8
movq (%r15), %rcx
leaq 0x7d43(%rip), %rdi      # 0xd0d7
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
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
pushq $0xa
popq %rdi
callq 0x51f0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x575c
movq 0x8(%rbx), %rax
addq $-0x3, %rax
cmpq %rax, (%rbx)
jb 0x5769
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a80
movb (%r14), %al
incq %r14
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
testb %al, %al
jne 0x5748
movq (%rbx), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%rbx)
cmpq 0x10(%rbx), %rcx
jbe 0x57a2
cmpb $0xa, -0x2(%rax)
je 0x57a2
movq %rax, (%rbx)
movb $0xa, -0x1(%rax)
movq (%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rcx
cmpq %rcx, %rax
jbe 0x57b7
cmpb $0x5c, -0x2(%rax)
je 0x57bf
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x78b3(%rip), %rdi      # 0xd079
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b1c
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x57fa
movq 0x8(%rbx), %rax
addq $-0x5, %rax
cmpq %rax, (%rbx)
jb 0x5807
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a80
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 0x5830
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, (%rbx)
jmp 0x57e6
movq %r14, %rdi
callq 0x5160
movq (%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0x5847
cmpb $0xa, -0x1(%rax)
jne 0x586a
movq (%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
incq %rcx
cmpq %rcx, %rax
jbe 0x5862
cmpb $0x5c, -0x2(%rax)
je 0x5884
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0xa, (%rax)
leaq 0x7819(%rip), %rdi      # 0xd094
xorl %eax, %eax
callq 0x5320
jmp 0x5847
leaq 0x77ee(%rip), %rdi      # 0xd079
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58fc
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 0xd6d5(%rip), %r15      # 0x12fd8
movq (%r15), %rcx
leaq 0x77d8(%rip), %rdi      # 0xd0e5
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_O1/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, 0xddbc(%rip)      # 0x13720
movq %rsi, 0xddbd(%rip)      # 0x13728
testl %edi, %edi
je 0x597e
pushq %rax
movq (%rsi), %rdi
callq 0x5b1c
addq $0x8, %rsp
jmp 0x5992
movl $0x1, 0xdd98(%rip)      # 0x13720
movq 0xd641(%rip), %rax      # 0x12fd0
movq (%rax), %rax
movq %rax, 0xdd97(%rip)      # 0x13730
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7ad0
xorl %ebp, %ebp
cmpl $0x0, 0xdd2a(%rip)      # 0x136e0
jne 0x5a79
cmpl $0x0, 0xdd5d(%rip)      # 0x13720
jle 0x5a79
cmpq $0x0, 0x10(%rbx)
je 0x59dd
movq 0x8(%rbx), %rax
addq $-0x3, %rax
cmpq %rax, (%rbx)
jb 0x59ea
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a80
movq 0xdd3f(%rip), %rdi      # 0x13730
callq 0x50a0
cmpl $-0x1, %eax
jne 0x5a00
callq 0x5b51
cmpl $-0x1, %eax
je 0x5a18
cmpl $0xa, %eax
je 0x5a35
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
jmp 0x59c9
movq (%rbx), %rax
subq 0x10(%rbx), %rax
movslq %r14d, %rcx
cmpq %rcx, %rax
je 0x5a79
leaq 0x7689(%rip), %rdi      # 0xd0b7
xorl %eax, %eax
callq 0x5320
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0xdcee(%rip), %rdi      # 0x13730
callq 0x50a0
cmpl $-0x1, %eax
jne 0x5a51
callq 0x5b51
cmpl $-0x1, %eax
je 0x5a64
movq 0xdcd3(%rip), %rsi      # 0x13730
movl %eax, %edi
callq 0x5070
incl 0xdc6e(%rip)            # 0x136d8
movl $0x0, 0xdc70(%rip)      # 0x136e4
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5aea
subl %r14d, %r12d
movq 0x10(%rbx), %rax
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      # 0xd06c
xorl %eax, %eax
callq 0x5899
// File: /workspace/github_cpp_makefile_star2_O1/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      # 0xd2d5
callq 0x51c0
testq %rax, %rax
je 0x5b33
popq %rbx
retq
leaq 0x758e(%rip), %rdi      # 0xd0c8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x5899
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl 0xdbc9(%rip), %ecx      # 0x13720
leal -0x1(%rcx), %eax
movl %eax, 0xdbc0(%rip)      # 0x13720
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
jl 0x5bbe
pushq %rax
movq 0xdbbe(%rip), %rdi      # 0x13730
callq 0x5160
movq 0xdbaa(%rip), %rax      # 0x13728
leaq 0x8(%rax), %rcx
movq %rcx, 0xdb9f(%rip)      # 0x13728
movq 0x8(%rax), %rdi
callq 0x5b1c
movq %rax, 0xdb97(%rip)      # 0x13730
movq %rax, %rdi
callq 0x50a0
cmpl $-0x1, %eax
jne 0x5bba
movl 0xdb74(%rip), %ecx      # 0x13720
leal -0x1(%rcx), %edx
movl %edx, 0xdb6b(%rip)      # 0x13720
cmpl $0x2, %ecx
jge 0x5b6b
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: addr(Text*, Text*)
int
addr(Text *script, Text *t)
{
	int n;
	switch(*t->w) {
	default:
		return 0;
	case '$':
		t->w++;
		n = DOLLAR;
		break;
	case '\\':
		t->w++;
		if(*t->w=='\n' ||*t->w=='\\')
			syntax("bad regexp delimiter");
	case '/':
		n = recomp(&rebuf, t, *t->w++) | REGADR;
		break;
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		n = number(t);
		if(n == 0)
			syntax("address is zero");
	}
	putint(script, n);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movzbl (%rcx), %edx
leal -0x30(%rdx), %eax
cmpl $0xa, %eax
jae 0x5f50
movq %r14, %rdi
callq 0x62e0
movl %eax, %ebp
testl %eax, %eax
jne 0x5fdd
movq 0xd83a(%rip), %r14      # 0x13758
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r14, %rax
leaq 0x741c(%rip), %rdi      # 0xd351
leaq 0x7251(%rip), %rsi      # 0xd18d
xorl %ebp, %ebp
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x5899
jmp 0x5fdd
cmpl $0x5c, %edx
je 0x5f72
cmpl $0x2f, %edx
je 0x5fb9
xorl %eax, %eax
cmpl $0x24, %edx
jne 0x5fec
incq %rcx
movq %rcx, (%r14)
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jmp 0x5fdd
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
movzbl 0x1(%rcx), %eax
cmpl $0x5c, %eax
je 0x5f87
cmpl $0xa, %eax
jne 0x5fb9
movq 0xd7ca(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x73ac(%rip), %rdi      # 0xd351
leaq 0x71cc(%rip), %rsi      # 0xd178
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x5899
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %edx
leaq 0xd773(%rip), %rdi      # 0x13740
movq %r14, %rsi
callq 0x7bdc
movl %eax, %ebp
orl $0x80000000, %ebp       # imm = 0x80000000
movq %rbx, %rdi
movl %ebp, %esi
callq 0x62a4
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: pack(int, int, int)
int
pack(int neg, int cmd, int length)
{
	int l = length & LMASK;
	if(length != l)
		syntax("<command-list> or <text> too long");
	return IMASK | neg | cmd << 2*BYTE | l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %ebp
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x60bb
movq 0xd6c8(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x72aa(%rip), %rdi      # 0xd351
leaq 0x7099(%rip), %rsi      # 0xd147
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x5899
movzwl %r14w, %eax
shll $0x10, %ebx
orl %ebp, %ebx
orl %eax, %ebx
orl $0xc0000000, %ebx       # imm = 0xC0000000
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: fixbrack(Text*)
void
fixbrack(Text *script)
{
	uchar *p;
	int *q;
	if(brack.w == 0)
		return;
	if(brack.w > brack.s)
		syntax("unmatched {");
	for(p=script->s; p<script->w; p=succi(p)) {
		q = instr(p);
		if(code(*q) == '{')
			*q += (uchar*)q - p;
	}
	free(brack.s);
}

// Assembly:
movq 0xd6b0(%rip), %rax      # 0x13790
testq %rax, %rax
je 0x61a5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq 0xd6a9(%rip), %rax      # 0x137a0
jbe 0x612b
movq 0xd658(%rip), %r14      # 0x13758
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r14, %rax
leaq 0x723a(%rip), %rdi      # 0xd351
leaq 0x713a(%rip), %rsi      # 0xd258
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x5899
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jae 0x6192
movq $-0x4, %rdx
movl 0x4(%rcx,%rdx), %esi
movl %esi, %edi
shrl $0x1e, %edi
addq $0x4, %rdx
cmpl $0x3, %edi
jb 0x613e
movl %esi, %edi
andl $0xff0000, %edi         # imm = 0xFF0000
cmpl $0x7b0000, %edi         # imm = 0x7B0000
jne 0x6165
addl %edx, %esi
movl %esi, (%rcx,%rdx)
movq %rcx, %rdx
movl (%rdx), %esi
movl %esi, %edi
shrl $0x1e, %edi
addq $0x4, %rdx
cmpl $0x3, %edi
jb 0x6168
movl %esi, %edi
andl $0xff0000, %edi         # imm = 0xFF0000
movzwl %si, %esi
addq %rsi, %rcx
cmpl $0x7b0000, %edi         # imm = 0x7B0000
cmoveq %rdx, %rcx
jmp 0x6132
movq 0xd607(%rip), %rdi      # 0x137a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51d0
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: fixlabels(Text*)
void
fixlabels(Text *script)
{
	uchar *p;
	int *q;
	for(p=script->s; p<script->w; p=succi(p)) {
		q = instr(p);
		switch(code(*q)) {
		case 't':
		case 'b':
			if(q[1] == -1)
				q[1] = script->w - script->s;
			else if(*(intptr_t*)(labels.s+q[1]) != -1)
				q[1] = *(intptr_t*)(labels.s+q[1]);
			else
				quit("undefined label: ",
					labels.s+q[1]+sizeof(intptr_t));
		}
	}
	free(labels.s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %r15
cmpq %rax, %r15
jae 0x624f
movq %rdi, %rbx
leaq 0x7012(%rip), %r14      # 0xd1d7
movq %r15, %rcx
movl (%rcx), %edx
addq $0x4, %rcx
cmpl $0xc0000000, %edx       # imm = 0xC0000000
jb 0x61c8
shrl $0x10, %edx
cmpb $0x74, %dl
je 0x61e6
movzbl %dl, %edx
cmpl $0x62, %edx
jne 0x6218
movslq (%rcx), %rdx
cmpq $-0x1, %rdx
je 0x6213
movq 0xd57a(%rip), %rsi      # 0x13770
movq (%rsi,%rdx), %rax
cmpq $-0x1, %rax
jne 0x6216
addq %rdx, %rsi
addq $0x8, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x5899
jmp 0x6218
subl 0x10(%rbx), %eax
movl %eax, (%rcx)
movq %r15, %rax
movl (%rax), %ecx
movl %ecx, %edx
shrl $0x1e, %edx
addq $0x4, %rax
cmpl $0x3, %edx
jb 0x621b
movl %ecx, %edx
andl $0xff0000, %edx         # imm = 0xFF0000
movzwl %cx, %ecx
addq %rcx, %r15
cmpl $0x7b0000, %edx         # imm = 0x7B0000
cmoveq %rax, %r15
movq (%rbx), %rax
cmpq %rax, %r15
jb 0x61c5
movq 0xd51a(%rip), %rdi      # 0x13770
popq %rbx
popq %r14
popq %r15
jmp 0x51d0
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: succi(unsigned char*)
uchar *
succi(uchar *p)
{
	int *q = instr(p);
	if(code(*q) == '{')
		return (uchar*)(q+1);
	else
		return p + (*q & LMASK);
}

// Assembly:
movq %rdi, %rax
movq %rdi, %rcx
movl (%rcx), %edx
movl %edx, %esi
shrl $0x1e, %esi
addq $0x4, %rcx
cmpl $0x3, %esi
jb 0x627b
movl %edx, %esi
andl $0xff0000, %esi         # imm = 0xFF0000
movzwl %dx, %edx
addq %rdx, %rax
cmpl $0x7b0000, %esi         # imm = 0x7B0000
cmoveq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: number(Text*)
int
number(Text *t)
{
	unsigned n = 0;
	while(isdigit(*t->w)) {
		if(n > (INT_MAX-9)/10)
			syntax("number too big");
		n = n*10 + *t->w++ - '0';
	}
	return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
movzbl (%rax), %eax
addl $-0x30, %eax
xorl %r12d, %r12d
cmpl $0x9, %eax
ja 0x6366
movq %rdi, %rbx
leaq 0x704d(%rip), %r14      # 0xd351
leaq 0x6e5e(%rip), %r15      # 0xd169
xorl %r12d, %r12d
cmpl $0xccccccc, %r12d       # imm = 0xCCCCCCC
jb 0x6341
movq 0xd43a(%rip), %r13      # 0x13758
movq %r13, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r13, %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x5899
leal (%r12,%r12,4), %eax
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movzbl (%rcx), %edx
leal (%rdx,%rax,2), %r12d
addl $-0x30, %r12d
movzbl 0x1(%rcx), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x630e
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: lablook(unsigned char*, Text*)
intptr_t *
lablook(uchar *l, Text *labels)
{
	uchar *p, *q;
	int n;
	assure(labels, 1);
	for(p = labels->s; p < labels->w; ) {
		q = p + sizeof(intptr_t);
		if(ustrcmp(q, l) == 0)
			return (intptr_t*)p;
		q += ustrlen(q) + 1;
		p = (uchar*)intptrp(q);
	}
	n = ustrlen(l);
	assure(labels, sizeof(intptr_t)+n+1+sizeof(intptr_t));
	*(intptr_t*)p = -1;
	q = p + sizeof(intptr_t);
	ustrcpy(q, l);
	q += ustrlen(q) + 1;
	labels->w = (uchar*)intptrp(q);
	return (intptr_t*)p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
je 0x63a7
movq 0x8(%rbx), %rax
addq $-0x2, %rax
cmpq %rax, (%rbx)
jb 0x63b4
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a80
movq (%rbx), %r13
movq 0x10(%rbx), %rbp
movq %rbp, %r15
cmpq %r13, %rbp
jae 0x63f2
movq %rbp, %r15
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5240
testl %eax, %eax
je 0x6444
movq %r12, %rdi
callq 0x50d0
leaq (%r12,%rax), %r15
addq $0x8, %r15
andq $-0x8, %r15
cmpq %r13, %r15
jb 0x63c6
movq %r14, %rdi
callq 0x50d0
testq %rbp, %rbp
je 0x640b
movslq %eax, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %r13
jb 0x6418
addl $0x11, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x5a80
movq $-0x1, (%r15)
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5150
movq %r12, %rdi
callq 0x50d0
addq %r15, %rax
addq $0x10, %rax
andq $-0x8, %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: getlab(Text*, int)
int
getlab(Text *t, int i)
{
	intptr_t *p;
	uchar *u;
	while(blank(t));	/* not exactly posix */
	for(u=t->w; *t->w!='\n'; t->w++)
		if(!isprint(*t->w) || *t->w==' ')
			synwarn("invisible character in name");
	if(u == t->w)
		return -1;
	*t->w = 0;
	p = lablook(u, &labels);
	if(*p == -1)
		*p = i;
	else if(i != -1)
		syntax("duplicate label");
	*t->w = '\n';
	return (uchar*)p - labels.s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x20, %ecx
je 0x647a
cmpl $0x9, %ecx
jne 0x647f
movq %rax, (%rbx)
jmp 0x6469
movq (%rbx), %r14
movb (%r14), %al
movq %r14, %rcx
cmpb $0xa, %al
je 0x64eb
leaq 0x6ebe(%rip), %r15      # 0xd351
leaq 0x6d03(%rip), %r12      # 0xd19d
movzbl %al, %r13d
movl %r13d, %edi
callq 0x52c0
cmpb $0x20, %r13b
je 0x64b0
testl %eax, %eax
jne 0x64da
movq 0xd2a1(%rip), %r13      # 0x13758
movq %r13, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r13, %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x5320
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb 0x1(%rax), %al
cmpb $0xa, %al
jne 0x649a
cmpq %rcx, %r14
je 0x6544
movb $0x0, (%rcx)
leaq 0xd266(%rip), %rsi      # 0x13760
movq %r14, %rdi
callq 0x6382
movq %rax, %r14
cmpq $-0x1, (%rax)
je 0x654c
cmpl $-0x1, %ebp
je 0x6552
movq 0xd241(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x6e23(%rip), %rdi      # 0xd351
leaq 0x6c84(%rip), %rsi      # 0xd1b9
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x5899
jmp 0x6552
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x6561
movslq %ebp, %rax
movq %rax, (%r14)
movq (%rbx), %rax
movb $0xa, (%rax)
movl 0xd212(%rip), %eax      # 0x13770
subl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq