LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4970
testb $0x1, %al
jne 0x60af
jmp 0x60bc
movq $0x44, -0x8(%rbp)
jmp 0x61e1
movq -0x20(%rbp), %rdi
callq 0x97b0
testb $0x1, %al
jne 0x60cb
jmp 0x60e9
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0x8cf0
shlq $0x3, %rax
addq $0x44, %rax
movq %rax, -0x8(%rbp)
jmp 0x61e1
movq -0x20(%rbp), %rdi
movq $0x44, -0x18(%rbp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x6108
jmp 0x6125
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x6090
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x6140
jmp 0x6161
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x6090
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x617c
jmp 0x619d
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
addq $0x20, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x6090
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x61b8
jmp 0x61d9
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x6090
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4970
testb $0x1, %al
jne 0x7c8f
jmp 0x7c94
jmp 0x7d53
movq -0x18(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rdi)
callq 0x97b0
testb $0x1, %al
jne 0x7cab
jmp 0x7cc2
movq -0x18(%rbp), %rdi
callq 0x4d50
movq -0x18(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x7d53
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x7d53
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9800
testb $0x1, %al
jne 0x7cf5
jmp 0x7d43
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x9830
movq %rax, %rdi
callq 0x7c70
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x9830
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd 0x18(%rcx), %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
jmp 0x7d45
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7cc9
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, 0x68(%rax)
jne 0xb7d7
movl $0x0, -0x4(%rbp)
jmp 0xb887
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbc90
movl $0x0, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2270
subq $0x1, %rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0xb86b
movslq -0x3c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2330
movq %rax, -0x60(%rbp)
jmp 0xb81b
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x3d(%rbp)
movsbl -0x3d(%rbp), %eax
cmpl $0x31, %eax
je 0xb836
movsbl -0x3d(%rbp), %eax
cmpl $0x33, %eax
jne 0xb858
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xb858
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20f0
jmp 0xb890
movl -0x38(%rbp), %eax
shll %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb802
movq -0x58(%rbp), %rax
movl (%rax), %eax
imull -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20f0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, 0x68(%rax)
jne 0xb8c7
movl $0x0, -0x4(%rbp)
jmp 0xb978
movq -0x58(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbc90
movl $0x0, -0x34(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2270
subq $0x1, %rax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0xb95b
movslq -0x3c(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2330
movq %rax, -0x60(%rbp)
jmp 0xb90b
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x3d(%rbp)
movsbl -0x3d(%rbp), %eax
cmpl $0x32, %eax
je 0xb926
movsbl -0x3d(%rbp), %eax
cmpl $0x33, %eax
jne 0xb948
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xb948
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20f0
jmp 0xb981
movl -0x38(%rbp), %eax
shll %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb8f2
movq -0x58(%rbp), %rax
movl 0x4(%rax), %eax
imull -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20f0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22e0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x68(%rax), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x68(%rax)
je 0xbe13
leaq -0x38(%rbp), %rdi
callq 0x2230
movq -0x78(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x28, %rdi
callq 0x9900
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0xbd17
leaq 0x583a(%rip), %rsi      # 0x11533
leaq -0x38(%rbp), %rdi
callq 0x2220
jmp 0xbd04
jmp 0xbd17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbe08
movq -0x78(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
callq 0x9900
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0xbd4c
leaq 0x54de(%rip), %rsi      # 0x1121d
leaq -0x38(%rbp), %rdi
callq 0x2220
jmp 0xbd4a
jmp 0xbd4c
movq -0x78(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x28, %rdi
addq $0x20, %rdi
callq 0x9900
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0xbd81
leaq 0x5553(%rip), %rsi      # 0x112c7
leaq -0x38(%rbp), %rdi
callq 0x2220
jmp 0xbd7f
jmp 0xbd81
movq -0x78(%rbp), %rax
movq 0x68(%rax), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
callq 0x9900
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0xbdb6
leaq 0x5c56(%rip), %rsi      # 0x119ff
leaq -0x38(%rbp), %rdi
callq 0x2220
jmp 0xbdb4
jmp 0xbdb6
movq -0x78(%rbp), %rax
movq 0x68(%rax), %rsi
leaq -0x68(%rbp), %rdi
callq 0xbc90
jmp 0xbdc9
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0xbe80
jmp 0xbddf
leaq -0x68(%rbp), %rdi
callq 0x20f0
leaq -0x38(%rbp), %rdi
callq 0x20f0
jmp 0xbe61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20f0
leaq -0x38(%rbp), %rdi
callq 0x20f0
jmp 0xbe6e
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x22f0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rdx
leaq 0x532b(%rip), %rsi      # 0x11163
callq 0xbed0
jmp 0xbe3f
leaq -0x69(%rbp), %rdi
callq 0x21e0
jmp 0xbe61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x21e0
jmp 0xbe6e
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22e0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x8c60
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jae 0xe477
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x5070
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe449
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x6070
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xe51e
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5070
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5050
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4c(%rbp)
addq $0x18, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x5050
movl -0x4c(%rbp), %ecx
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movl -0x3c(%rbp), %eax
imull (%rdx), %ecx
addl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x5070
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe47e
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4fa0
movq -0x70(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x4fc0
jmp 0xf28d
leaq -0x39(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x5070
movsd -0x98(%rbp), %xmm0
movq -0x88(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0x90(%rbp), %xmm0
movq -0x88(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x10030
jmp 0xf30d
movl -0x74(%rbp), %esi
movq -0x80(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0xff40
jmp 0xf31f
leaq -0x68(%rbp), %rdi
callq 0x5300
leaq -0x38(%rbp), %rdi
callq 0x5300
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x5030
jmp 0xf37d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xf374
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5300
leaq -0x38(%rbp), %rdi
callq 0x5300
movq -0x48(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4fa0
movq -0x78(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movl $0x3, %esi
callq 0x4fc0
jmp 0xf3d2
leaq -0x41(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5070
movsd -0xa8(%rbp), %xmm0
movq -0x90(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0xa0(%rbp), %xmm0
movq -0x90(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movl $0x2, %esi
callq 0x5070
movsd -0x98(%rbp), %xmm0
movq -0x90(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x10030
jmp 0xf47f
movl -0x7c(%rbp), %esi
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0xff40
jmp 0xf494
leaq -0x70(%rbp), %rdi
callq 0x5300
leaq -0x40(%rbp), %rdi
callq 0x5300
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x5030
jmp 0xf4f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xf4e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x5300
leaq -0x40(%rbp), %rdi
callq 0x5300
movq -0x50(%rbp), %rdi
callq 0x22e0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4fa0
movq -0x80(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movl $0x4, %esi
callq 0x4fc0
jmp 0xf547
leaq -0x49(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5070
movsd -0xb8(%rbp), %xmm0
movq -0x98(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0xb0(%rbp), %xmm0
movq -0x98(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movl $0x2, %esi
callq 0x5070
movsd -0xa8(%rbp), %xmm0
movq -0x98(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xa0(%rbp)
movl $0x3, %esi
callq 0x5070
movsd -0xa0(%rbp), %xmm0
movq -0x98(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x10030
jmp 0xf621
movl -0x84(%rbp), %esi
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xff40
jmp 0xf639
leaq -0x78(%rbp), %rdi
callq 0x5300
leaq -0x48(%rbp), %rdi
callq 0x5300
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x5030
jmp 0xf697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xf68e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5300
leaq -0x48(%rbp), %rdi
callq 0x5300
movq -0x58(%rbp), %rdi
callq 0x22e0
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4fa0
movq -0x88(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movl $0x5, %esi
callq 0x4fc0
jmp 0xf6f2
leaq -0x51(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5070
movsd -0xc8(%rbp), %xmm0
movq -0xa0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0xc0(%rbp), %xmm0
movq -0xa0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movl $0x2, %esi
callq 0x5070
movsd -0xb8(%rbp), %xmm0
movq -0xa0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movl $0x3, %esi
callq 0x5070
movsd -0xb0(%rbp), %xmm0
movq -0xa0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
movl $0x4, %esi
callq 0x5070
movsd -0xa8(%rbp), %xmm0
movq -0xa0(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x10030
jmp 0xf7f6
movl -0x8c(%rbp), %esi
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0xff40
jmp 0xf80e
leaq -0x80(%rbp), %rdi
callq 0x5300
leaq -0x50(%rbp), %rdi
callq 0x5300
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x5030
jmp 0xf86c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xf863
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5300
leaq -0x50(%rbp), %rdi
callq 0x5300
movq -0x60(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4fa0
movq -0x90(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movl $0x6, %esi
callq 0x4fc0
jmp 0xf8d7
leaq -0x59(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5070
movsd -0xd8(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0xd0(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
movl $0x2, %esi
callq 0x5070
movsd -0xc8(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movl $0x3, %esi
callq 0x5070
movsd -0xc0(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movl $0x4, %esi
callq 0x5070
movsd -0xb8(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xb0(%rbp)
movl $0x5, %esi
callq 0x5070
movsd -0xb0(%rbp), %xmm0
movq -0xa8(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x10030
jmp 0xfa08
movl -0x94(%rbp), %esi
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0xff40
jmp 0xfa23
leaq -0x88(%rbp), %rdi
callq 0x5300
leaq -0x58(%rbp), %rdi
callq 0x5300
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x5030
jmp 0xfa87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xfa7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5300
leaq -0x58(%rbp), %rdi
callq 0x5300
movq -0x68(%rbp), %rdi
callq 0x22e0
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
movsd %xmm6, -0x48(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4fa0
movq -0x98(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movl $0x7, %esi
callq 0x4fc0
jmp 0xfaec
leaq -0x61(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x5070
movsd -0xe8(%rbp), %xmm0
movq -0xb0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0xe0(%rbp), %xmm0
movq -0xb0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movl $0x2, %esi
callq 0x5070
movsd -0xd8(%rbp), %xmm0
movq -0xb0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movl $0x3, %esi
callq 0x5070
movsd -0xd0(%rbp), %xmm0
movq -0xb0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
movl $0x4, %esi
callq 0x5070
movsd -0xc8(%rbp), %xmm0
movq -0xb0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movl $0x5, %esi
callq 0x5070
movsd -0xc0(%rbp), %xmm0
movq -0xb0(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0xb8(%rbp)
movl $0x6, %esi
callq 0x5070
movsd -0xb8(%rbp), %xmm0
movq -0xb0(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x10030
jmp 0xfc47
movl -0x9c(%rbp), %esi
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0xff40
jmp 0xfc62
leaq -0x90(%rbp), %rdi
callq 0x5300
leaq -0x60(%rbp), %rdi
callq 0x5300
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x5030
jmp 0xfcc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0xfcbd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5300
leaq -0x60(%rbp), %rdi
callq 0x5300
movq -0x70(%rbp), %rdi
callq 0x22e0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movsd %xmm4, -0x38(%rbp)
movsd %xmm5, -0x40(%rbp)
movsd %xmm6, -0x48(%rbp)
movsd %xmm7, -0x50(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x4fa0
movq -0xa0(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movl $0x8, %esi
callq 0x4fc0
jmp 0xfd31
leaq -0x69(%rbp), %rdi
callq 0x5030
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0xf8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5070
movsd -0xf8(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0xf0(%rbp)
movl $0x1, %esi
callq 0x5070
movsd -0xf0(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0xe8(%rbp)
movl $0x2, %esi
callq 0x5070
movsd -0xe8(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
movl $0x3, %esi
callq 0x5070
movsd -0xe0(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movl $0x4, %esi
callq 0x5070
movsd -0xd8(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movl $0x5, %esi
callq 0x5070
movsd -0xd0(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0xc8(%rbp)
movl $0x6, %esi
callq 0x5070
movsd -0xc8(%rbp), %xmm0
movq -0xb8(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x50(%rbp), %xmm0
movsd %xmm0, -0xc0(%rbp)
movl $0x7, %esi
callq 0x5070
movsd -0xc0(%rbp), %xmm0
movq -0xb8(%rbp), %rsi
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0xa4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x10030
jmp 0xfeb6
movl -0xa4(%rbp), %esi
movq -0xb0(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0xff40
jmp 0xfed1
leaq -0x98(%rbp), %rdi
callq 0x5300
leaq -0x68(%rbp), %rdi
callq 0x5300
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x5030
jmp 0xff35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xff2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x5300
leaq -0x68(%rbp), %rdi
callq 0x5300
movq -0x78(%rbp), %rdi
callq 0x22e0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6070
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x8cf0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rsi
callq 0xb990
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xb990
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xba90
movq $0x0, -0x28(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x8cf0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x1002a
movq -0x38(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x7e70
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x28(%rbp), %rax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x7c10
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rdi
addq $0x30, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rsi
callq 0x5070
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xbb90
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xffb5
addq $0x60, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5677
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x2, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x5687
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x5ae0
jmp 0x5689
jmp 0x5689
jmp 0x568b
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %al, (%rcx)
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5650
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
addq $-0x1, %rax
movq %rax, (%rcx)
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x56fd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl -0x1(%rax), %eax
cmpl $0xa, %eax
je 0x56fd
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0xa, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x5bb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ce0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5754
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x4, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x5764
movq -0x8(%rbp), %rdi
movl $0x4, %esi
callq 0x5ae0
jmp 0x5766
jmp 0x5766
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq %rax, %rdx
subq $0x3, %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x5290
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x579c
jmp 0x57b4
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
jmp 0x572d
movq -0x20(%rbp), %rdi
callq 0x5190
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x5800
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl -0x1(%rax), %eax
cmpl $0xa, %eax
je 0x5800
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0xa, (%rax)
leaq 0xb89b(%rip), %rdi      # 0x11094
movb $0x0, %al
callq 0x5c00
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x5bb0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5855
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x11755(%rip), %rax     # 0x16fd8
movq (%rax), %rdi
leaq 0xb858(%rip), %rsi      # 0x110e5
movb $0x0, %al
callq 0x5260
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x11719(%rip), %rax     # 0x16fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5230
leaq -0x20(%rbp), %rax
movq 0x116fe(%rip), %rax     # 0x16fd8
movq (%rax), %rdi
leaq 0xb786(%rip), %rsi      # 0x1106a
movb $0x0, %al
callq 0x5260
movl $0x1, %edi
callq 0x5200
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x12848(%rip)     # 0x18160
movq -0x10(%rbp), %rax
movq %rax, 0x12845(%rip)     # 0x18168
cmpl $0x0, 0x12836(%rip)     # 0x18160
jne 0x5949
movl $0x1, 0x1282a(%rip)     # 0x18160
movq 0x11693(%rip), %rax     # 0x16fd0
movq (%rax), %rax
movq %rax, 0x12829(%rip)     # 0x18170
jmp 0x595f
movq 0x12818(%rip), %rax     # 0x18168
movq (%rax), %rdi
callq 0x5ce0
movq %rax, 0x12811(%rip)     # 0x18170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x18(%rbp)
callq 0x8940
cmpl $0x0, 0x12783(%rip)     # 0x18120
jne 0x59a9
callq 0x5d30
cmpl $0x0, %eax
je 0x59b5
movl $0x0, -0x4(%rbp)
jmp 0x5ad2
jmp 0x59b7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x59de
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x2, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x59ee
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x5ae0
jmp 0x59f0
jmp 0x59f0
movq 0x12779(%rip), %rdi     # 0x18170
callq 0x50a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x5a0e
callq 0x5d50
movl %eax, -0x14(%rbp)
jmp 0x5a10
jmp 0x5a10
cmpl $0xa, -0x14(%rbp)
jne 0x5a18
jmp 0x5a73
cmpl $-0x1, -0x14(%rbp)
je 0x5a38
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x5a6c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5a5c
movl $0x0, -0x4(%rbp)
jmp 0x5ad2
leaq 0xb654(%rip), %rdi      # 0x110b7
movb $0x0, %al
callq 0x5c00
jmp 0x5a73
jmp 0x5a6e
jmp 0x59b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq 0x126ec(%rip), %rdi     # 0x18170
callq 0x50a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x5a9b
callq 0x5d50
movl %eax, -0x14(%rbp)
jmp 0x5a9d
jmp 0x5a9d
cmpl $-0x1, -0x14(%rbp)
je 0x5ab2
movl -0x14(%rbp), %edi
movq 0x126c3(%rip), %rsi     # 0x18170
callq 0x5070
movl 0x12660(%rip), %eax     # 0x18118
addl $0x1, %eax
movl %eax, 0x12657(%rip)     # 0x18118
movl $0x0, 0x12659(%rip)     # 0x18124
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x2000, %ecx           # imm = 0x2000
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
addl $0x1, %ecx
shll $0xd, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rsi
callq 0x52c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5b70
leaq 0xb503(%rip), %rdi      # 0x1106c
movb $0x0, %al
callq 0x5820
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x5c35
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x11375(%rip), %rax     # 0x16fd8
movq %rax, -0xe0(%rbp)
movq (%rax), %rdi
leaq 0xb463(%rip), %rsi      # 0x110d7
xorl %eax, %eax
movb %al, -0xd1(%rbp)
callq 0x5260
movq -0xe0(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5230
movq -0xe0(%rbp), %rcx
movb -0xd1(%rbp), %al
movq (%rcx), %rdi
leaq 0xb39a(%rip), %rsi      # 0x1106a
callq 0x5260
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb7e5(%rip), %rsi      # 0x114dc
callq 0x51e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5d19
movq -0x8(%rbp), %rsi
leaq 0xb3b6(%rip), %rdi      # 0x110c8
movb $0x0, %al
callq 0x5820
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: gopen()
int
gopen(void)
{
	int c = EOF;
	while(c==EOF && --input.iargc > 0) {
		fclose(input.ifile);
		input.ifile = aopen(*++input.iargv);
		c = getc(input.ifile);
	}
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
cmpl $-0x1, -0x4(%rbp)
movb %al, -0x5(%rbp)
jne 0x5d82
movl 0x123f0(%rip), %eax     # 0x18160
addl $-0x1, %eax
movl %eax, 0x123e7(%rip)     # 0x18160
cmpl $0x0, %eax
setg %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x5d8b
jmp 0x5dcd
movq 0x123de(%rip), %rdi     # 0x18170
callq 0x5190
movq 0x123ca(%rip), %rax     # 0x18168
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x123bc(%rip)     # 0x18168
movq 0x8(%rax), %rdi
callq 0x5ce0
movq %rax, 0x123b4(%rip)     # 0x18170
movq 0x123ad(%rip), %rdi     # 0x18170
callq 0x50a0
movl %eax, -0x4(%rbp)
jmp 0x5d5f
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: blank(Text*)
int
blank(Text *t)
{
	if(*t->w==' ' || *t->w=='\t') {
		t->w++;
		return 1;
	} else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x60e6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x9, %eax
jne 0x60fd
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6104
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
addl $-0x24, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x38, %eax
ja 0x614c
movq -0x28(%rbp), %rax
leaq 0xafb1(%rip), %rcx      # 0x110f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x620d
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x7fffffff, -0x1c(%rbp) # imm = 0x7FFFFFFF
jmp 0x61fa
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x619e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x61aa
leaq 0xb1da(%rip), %rdi      # 0x1137f
callq 0x6220
jmp 0x61ac
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %edx
leaq 0x11fb5(%rip), %rdi     # 0x18180
callq 0x8a60
orl $0x80000000, %eax       # imm = 0x80000000
movl %eax, -0x1c(%rbp)
jmp 0x61fa
movq -0x18(%rbp), %rdi
callq 0x6600
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x61f8
leaq 0xb1a1(%rip), %rdi      # 0x11394
callq 0x6220
jmp 0x61fa
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x6590
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x6320
leaq 0xb033(%rip), %rdi      # 0x1134e
callq 0x6220
movl -0x4(%rbp), %eax
orl $0xc0000000, %eax       # imm = 0xC0000000
movl -0x8(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
orl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x11e7c(%rip)     # 0x181d0
jne 0x635b
jmp 0x63e4
movq 0x11e6e(%rip), %rax     # 0x181d0
cmpq 0x11e77(%rip), %rax     # 0x181e0
jbe 0x6377
leaq 0xb0ed(%rip), %rdi      # 0x1145f
callq 0x6220
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x63d8
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
sarl $0x10, %eax
andl $0xff, %eax
cmpl $0x7b, %eax
jne 0x63c7
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
addq %rdx, %rcx
movl %ecx, (%rax)
jmp 0x63c9
movq -0x10(%rbp), %rdi
callq 0x6530
movq %rax, -0x10(%rbp)
jmp 0x6383
movq 0x11e01(%rip), %rdi     # 0x181e0
callq 0x51f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)