LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/fileio.cpp
// Function: read_csv_vector_2d(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MatrixXd read_csv_vector_2d(string filename, string col_name0, string col_name1){
//    ファイル名と列名を入れるとMatrixXd(n行2列)を返す
    int col_number = 2;
    io::CSVReader<2> in(filename);
    in.read_header(io::ignore_extra_column, col_name0, col_name1);
    MatrixXd value = MatrixXd::Zero(1,col_number);
    double value0, value1;
    int max_col = 1;
    int now_col = 0;
    while(in.read_row(value0, value1)){
        value.conservativeResize(max_col, col_number);
        value(now_col, 0) = value0;
        value(now_col, 1) = value1;
        now_col++; max_col++;
    }
    return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp            # imm = 0x2A8
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
callq 0x16c6e
leaq 0x50(%rsp), %rdi
movq %r15, %rsi
callq 0x54c0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x54c0
leaq 0x70(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x16d9e
leaq 0x30(%rsp), %rdi
callq 0x56e8
leaq 0x50(%rsp), %rdi
callq 0x56e8
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
callq 0xfc8a
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x16ebe
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r12
pushq $0x1
popq %rbp
leaq 0x70(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x16f14
testb %al, %al
je 0x165fd
leaq 0x1(%r13), %r14
movq %rbx, %rdi
movq %r14, %rsi
pushq $0x2
popq %rdx
callq 0x1965e
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x6548
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x6548
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r14, %r13
jmp 0x1658b
leaq 0x70(%rsp), %rdi
callq 0x16fd2
movq %rbx, %rax
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x56e8
jmp 0x1662e
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x56e8
jmp 0x1664c
jmp 0x1663c
movq %rax, %r14
jmp 0x1664c
movq %rax, %r14
movq %rbx, %rdi
callq 0x6592
leaq 0x70(%rsp), %rdi
callq 0x16fd2
movq %r14, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/fileio.cpp
// Function: read_csv_vector_3d(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
MatrixXd read_csv_vector_3d(string filename,
                            string col_name0, string col_name1, string col_name2){
    //    ファイル名と列数を入れるとMatrixXd(n行3列)を返す
    int col_number = 3;
    io::CSVReader<3> in(filename);
    in.read_header(io::ignore_extra_column, col_name0, col_name1, col_name2);
    MatrixXd value = MatrixXd::Zero(1,col_number);
    double value0, value1, value2;
    int max_col = 1;
    int now_col = 0;
    while(in.read_row(value0, value1, value2)){
        value.conservativeResize(max_col, col_number);
        value(now_col, 0) = value0;
        value(now_col, 1) = value1;
        value(now_col, 2) = value2;
        now_col++; max_col++;
    }
    return value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x98(%rsp), %rdi
callq 0x17010
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x54c0
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x54c0
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x54c0
leaq 0x98(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x78(%rsp), %rdx
leaq 0x58(%rsp), %rcx
leaq 0x38(%rsp), %r8
callq 0x17154
leaq 0x38(%rsp), %rdi
callq 0x56e8
leaq 0x58(%rsp), %rdi
callq 0x56e8
leaq 0x78(%rsp), %rdi
callq 0x56e8
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x3
popq %rdx
callq 0xfc8a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x16ebe
xorl %r14d, %r14d
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %r13
pushq $0x2
popq %rbp
leaq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x172a8
testb %al, %al
je 0x167be
leaq 0x1(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
pushq $0x3
popq %rdx
callq 0x1965e
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6548
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
pushq $0x1
popq %rdx
callq 0x6548
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x6548
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq %r15, %r14
jmp 0x16719
leaq 0x98(%rsp), %rdi
callq 0x1736c
movq %rbx, %rax
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x56e8
jmp 0x167f2
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x56e8
jmp 0x16801
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x56e8
jmp 0x1681f
jmp 0x1680f
movq %rax, %r14
jmp 0x1681f
movq %rax, %r14
movq %rbx, %rdi
callq 0x6592
leaq 0x98(%rsp), %rdi
callq 0x1736c
movq %r14, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::CSVReader<3u, io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>, io::throw_on_overflow, io::no_comment>::CSVReader<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
explicit CSVReader(Args&&...args):in(std::forward<Args>(args)...){
                        std::fill(row, row+column_count, nullptr);
                        col_order.resize(column_count);
                        for(unsigned i=0; i<column_count; ++i)
                                col_order[i] = i;
                        for(unsigned i=1; i<=column_count; ++i)
                                column_names[i-1] = "col"+std::to_string(i);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x17caa
movl $0x1f8, %eax            # imm = 0x1F8
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
andq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x258, %rax            # imm = 0x258
jne 0x1702b
leaq 0x248(%rbx), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x248(%rbx)
andq $0x0, 0x258(%rbx)
movl $0x1d0, %eax            # imm = 0x1D0
cmpq $0x1e8, %rax            # imm = 0x1E8
je 0x1707b
andq $0x0, (%rbx,%rax)
addq $0x8, %rax
jmp 0x17068
pushq $0x3
popq %rsi
movq %r14, %rdi
movq %r14, (%rsp)
callq 0x17d1e
leaq 0x1e8(%rbx), %r15
movq (%r14), %rax
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x170a4
movl %ecx, (%rax,%rcx,4)
incq %rcx
jmp 0x17096
pushq $-0x3
popq %r14
leaq 0x8(%rsp), %r12
leaq 0xb62d(%rip), %r13      # 0x226e1
leaq 0x28(%rsp), %rbp
testq %r14, %r14
je 0x170fc
leal 0x4(%r14), %esi
movq %r12, %rdi
callq 0x17d4f
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xfa74
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5450
movq %rbp, %rdi
callq 0x56e8
movq %r12, %rdi
callq 0x56e8
incq %r14
addq $0x20, %r15
jmp 0x170b9
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1710d
movq %rax, %r15
jmp 0x1711f
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x56e8
movq (%rsp), %rdi
callq 0x17b3c
movl $0x228, %r14d           # imm = 0x228
leaq (%rbx,%r14), %rdi
callq 0x56e8
addq $-0x20, %r14
cmpq $0x1c8, %r14            # imm = 0x1C8
jne 0x1712e
movq %rbx, %rdi
callq 0x17b1e
movq %r15, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: bool io::CSVReader<2u, io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>, io::throw_on_overflow, io::no_comment>::read_row<double, double>(double&, double&)
bool read_row(ColType& ...cols){
                        static_assert(sizeof...(ColType)>=column_count,
                                "not enough columns specified");
                        static_assert(sizeof...(ColType)<=column_count,
                                "too many columns specified");
                        try{
                                try{
       
                                        char*line;
                                        do{
                                                line = in.next_line();
                                                if(!line)
                                                        return false;
                                        }while(comment_policy::is_comment(line));
                                       
                                        detail::parse_line<trim_policy, quote_policy>
                                                (line, row, col_order);
               
                                        parse_helper(0, cols...);
                                }catch(error::with_file_name&err){
                                        err.set_file_name(in.get_truncated_file_name());
                                        throw;
                                }
                        }catch(error::with_file_line&err){
                                err.set_file_line(in.get_file_line());
                                throw;
                        }

                        return true;
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x185d8
movq %rax, %r12
testq %rax, %rax
je 0x16f58
leaq 0x1d0(%rbx), %rsi
leaq 0x220(%rbx), %rdx
movq %r12, %rdi
callq 0x18fec
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x190f0
testq %r12, %r12
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x16f9f
movq %r14, %rdi
callq 0x5170
leaq 0xc8(%rbx), %rsi
movq %rax, %rdi
callq 0x182c2
callq 0x54e0
jmp 0x16fba
movq %rdx, %r15
movq %rax, %r14
callq 0x55a0
cmpl $0x1, %r15d
jne 0x16fc2
movq %r14, %rdi
callq 0x5170
movl 0x1c8(%rbx), %ecx
movl %ecx, (%rax)
callq 0x54e0
movq %rax, %r14
callq 0x55a0
movq %r14, %rdi
callq 0x5640
movq %rax, %rdi
callq 0x659a
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::CSVReader<15u, io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>, io::throw_on_overflow, io::no_comment>::set_header<char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*>(char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*, char const*)
void set_header(ColNames...cols){
                        static_assert(sizeof...(ColNames)>=column_count,
                                "not enough column names specified");
                        static_assert(sizeof...(ColNames)<=column_count,
                                "too many column names specified");
                        set_column_names(std::forward<ColNames>(cols)...);
                        std::fill(row, row+column_count, nullptr);
                        col_order.resize(column_count);
                        for(unsigned i=0; i<column_count; ++i)
                                col_order[i] = i;
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x58(%rsp), %rbp
leaq 0x57(%rsp), %rdx
movq %rbp, %rdi
callq 0x6c7e
movaps 0xf0(%rsp), %xmm0
movups %xmm0, 0x40(%rsp)
movaps 0xe0(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
movaps 0xd0(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
movaps 0xc0(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movaps 0xb0(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x1a96c
leaq 0x58(%rsp), %rdi
callq 0x56e8
pushq $-0x78
popq %rax
testq %rax, %rax
je 0x1796f
andq $0x0, 0x248(%rbx,%rax)
addq $0x8, %rax
jmp 0x1795b
leaq 0x428(%rbx), %rdi
pushq $0xf
popq %rsi
callq 0x17d1e
movq 0x428(%rbx), %rax
xorl %ecx, %ecx
cmpq $0xf, %rcx
je 0x17995
movl %ecx, (%rax,%rcx,4)
incq %rcx
jmp 0x17987
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x56e8
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::detail::AsynchronousReader::~AsynchronousReader()
~AsynchronousReader(){
                                if(byte_source != 0){
                                        {
                                                std::unique_lock<std::mutex>guard(lock);
                                                termination_requested = true;
                                        }
                                        read_requested_condition.notify_one();
                                        worker.join();
                                }
                        }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x17bab
leaq 0x30(%rbx), %rsi
movq %rsp, %rdi
callq 0x17be8
movb $0x1, 0x10(%rbx)
movq %rsp, %rdi
callq 0x17bfe
leaq 0x88(%rbx), %rdi
callq 0x51d0
leaq 0x8(%rbx), %rdi
callq 0x5600
leaq 0x88(%rbx), %rdi
callq 0x5670
leaq 0x58(%rbx), %rdi
callq 0x5670
leaq 0x18(%rbx), %rdi
callq 0x17c14
leaq 0x8(%rbx), %rdi
callq 0x17c20
movq %rbx, %rdi
callq 0x17c2e
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x659a
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::LineReader::init(std::unique_ptr<io::ByteSourceBase, std::default_delete<io::ByteSourceBase>>)
void init(std::unique_ptr<ByteSourceBase>byte_source){
                        file_line = 0;

                        buffer = new char[3*block_len];
                        try{
                                data_begin = 0;
                                data_end = byte_source->read(buffer, 2*block_len);

                                // Ignore UTF-8 BOM
                                if(data_end >= 3 && buffer[0] == '\xEF' && buffer[1] == '\xBB' && buffer[2] == '\xBF')
                                        data_begin = 3;

                                if(data_end == 2*block_len){
                                        reader.init(std::move(byte_source));
                                        reader.start_read(buffer + 2*block_len, block_len);
                                }
                        }catch(...){
                                delete[]buffer;
                                throw;
                        }
                }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andl $0x0, 0x1c8(%rdi)
movl $0x3000000, %edi        # imm = 0x3000000
callq 0x5030
movq %rax, 0xb8(%rbx)
andl $0x0, 0xc0(%rbx)
movq (%r14), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
movl $0x2000000, %edx        # imm = 0x2000000
callq *(%rcx)
movl %eax, 0xc4(%rbx)
cmpl $0x3, %eax
jl 0x17e91
movq 0xb8(%rbx), %rcx
cmpb $-0x11, (%rcx)
jne 0x17e48
cmpb $-0x45, 0x1(%rcx)
jne 0x17e48
cmpb $-0x41, 0x2(%rcx)
jne 0x17e48
movl $0x3, 0xc0(%rbx)
cmpl $0x2000000, %eax        # imm = 0x2000000
jne 0x17e91
movq (%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
andq $0x0, (%r14)
movq %rbx, %rdi
callq 0x18008
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17e73
movq (%rdi), %rax
callq *0x10(%rax)
andq $0x0, (%rsp)
movl $0x2000000, %esi        # imm = 0x2000000
addq 0xb8(%rbx), %rsi
movq %rbx, %rdi
movl $0x1000000, %edx        # imm = 0x1000000
callq 0x1808c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x17eab
movq (%rdi), %rax
callq *0x10(%rax)
andq $0x0, (%rsp)
jmp 0x17eb5
movq %rax, %r14
movq %r14, %rdi
callq 0x5170
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x17ece
callq 0x5480
callq 0x54e0
movq %rax, %rbx
callq 0x55a0
movq %rbx, %rdi
callq 0x5640
movq %rax, %rdi
callq 0x659a
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::LineReader::open_file(char const*)
static std::unique_ptr<ByteSourceBase> open_file(const char*file_name){
                        // We open the file in binary mode as it makes no difference under *nix
                        // and under Windows we handle \r\n newlines ourself.
                        FILE*file = std::fopen(file_name, "rb");
                        if(file == 0){
                                int x = errno; // store errno as soon as possible, doing it after constructor call can fail.
                                error::can_not_open_file err;
                                err.set_errno(x);
                                err.set_file_name(file_name);
                                throw err;
                        }
                        return std::unique_ptr<ByteSourceBase>(new detail::OwningStdIOByteSourceBase(file));
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa7db(%rip), %rsi      # 0x226e5
movq %r15, %rdi
callq 0x5420
testq %rax, %rax
je 0x17f48
movq %rax, %r14
pushq $0x10
popq %rdi
callq 0x5390
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x182da
movq %r15, (%rbx)
movq %rbx, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5060
movl (%rax), %ebp
movl $0x108, %ebx            # imm = 0x108
leaq 0x8(%rsp), %r12
leaq (%r12,%rbx), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x5220
leaq 0x16945(%rip), %r13     # 0x2e8b8
movq %r13, (%r12)
movl %ebp, 0x208(%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x182c2
movl $0x210, %edi            # imm = 0x210
callq 0x51c0
movq %rax, %r15
leaq 0x1694a(%rip), %rax     # 0x2e8e8
movq %rax, (%r15)
leaq 0x8(%r15), %rdi
leaq 0x10(%rsp), %r12
movl $0x100, %edx            # imm = 0x100
movq %r12, %rsi
callq 0x52f0
addq %r15, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52f0
movl 0x200(%r12), %eax
movl %eax, 0x208(%r15)
movq %r13, (%r15)
leaq 0x1687d(%rip), %rsi     # 0x2e860
movq 0x16fe6(%rip), %rdx     # 0x2efd0
movq %r15, %rdi
callq 0x5610
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56f0
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::detail::AsynchronousReader::init(std::unique_ptr<io::ByteSourceBase, std::default_delete<io::ByteSourceBase>>)
void init(std::unique_ptr<ByteSourceBase>arg_byte_source){
                                std::unique_lock<std::mutex>guard(lock);
                                byte_source = std::move(arg_byte_source);
                                desired_byte_count = -1;
                                termination_requested = false;
                                worker = std::thread(
                                        [&]{
                                                std::unique_lock<std::mutex>guard(lock);
                                                try{
                                                        for(;;){
                                                                read_requested_condition.wait(
                                                                        guard, 
                                                                        [&]{
                                                                                return desired_byte_count != -1 || termination_requested;
                                                                        }
                                                                );
                                                                if(termination_requested)
                                                                        return;

                                                                read_byte_count = byte_source->read(buffer, desired_byte_count);
                                                                desired_byte_count = -1;
                                                                if(read_byte_count == 0)
                                                                        break;
                                                                read_finished_condition.notify_one();
                                                        }
                                                }catch(...){
                                                        read_error = std::current_exception();
                                                }
                                                read_finished_condition.notify_one();
                                        }
                                );
                        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x10(%rsp), %rdi
callq 0x17be8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18162
orl $-0x1, 0x28(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x20(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x180e0
addq $0x8, %rbx
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18148
movq %r14, %rdi
callq 0x17c20
leaq 0x10(%rsp), %rdi
callq 0x17bfe
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x17bfe
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::detail::AsynchronousReader::start_read(char*, int)
void start_read(char*arg_buffer, int arg_desired_byte_count){
                                std::unique_lock<std::mutex>guard(lock);
                                buffer = arg_buffer;
                                desired_byte_count = arg_desired_byte_count;
                                read_byte_count = -1;
                                read_requested_condition.notify_one();
                        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x17be8
movq %r14, 0x20(%r15)
movl %ebx, 0x28(%r15)
orl $-0x1, 0x2c(%r15)
addq $0x88, %r15
movq %r15, %rdi
callq 0x51d0
movq %r12, %rdi
callq 0x17bfe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::error::can_not_open_file::format_error_message() const
void format_error_message()const{
                                if(errno_value != 0)
                                        std::snprintf(error_message_buffer, sizeof(error_message_buffer),
                                                "Can not open file \"%s\" because \"%s\"."
                                                , file_name, std::strerror(errno_value));
                                else
                                        std::snprintf(error_message_buffer, sizeof(error_message_buffer),
                                                "Can not open file \"%s\"."
                                                , file_name);
                        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x208(%rdi), %edi
leaq 0x8(%rbx), %r14
addq $0x108, %rbx            # imm = 0x108
testl %edi, %edi
je 0x18370
callq 0x5140
leaq 0xa394(%rip), %rdx      # 0x226e8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
movq %rax, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5560
leaq 0xa396(%rip), %rdx      # 0x2270d
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5560
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::detail::AsynchronousReader::finish_read()
int finish_read(){
                                std::unique_lock<std::mutex>guard(lock);
                                read_finished_condition.wait(
                                        guard, 
                                        [&]{
                                                return read_byte_count != -1 || read_error;
                                        }
                                );
                                if(read_error)
                                        std::rethrow_exception(read_error);
                                else
                                        return read_byte_count;
                        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17be8
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18c8e
cmpq $0x0, 0x18(%rbx)
jne 0x18c52
movl 0x2c(%rbx), %ebx
leaq 0x8(%rsp), %rdi
callq 0x17bfe
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
addq $0x18, %rbx
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18cbc
movq %r14, %rdi
callq 0x53b0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x17c14
jmp 0x18c7c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x17bfe
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::detail::chop_next_column<io::no_quote_escape<(char)44>>(char*&, char*&, char*&)
void chop_next_column(
                        char*&line, char*&col_begin, char*&col_end
                ){
                        assert(line != nullptr);

                        col_begin = line;
                        // the col_begin + (... - col_begin) removes the constness
                        col_end = col_begin + (quote_policy::find_next_column_end(col_begin) - col_begin);
                       
                        if(*col_end == '\0'){
                                line = nullptr;
                        }else{
                                *col_end = '\0';
                                line = col_end + 1;    
                        }
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x18d97
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %r15, (%rsi)
movq %r15, %rdi
callq 0x18e20
subq (%r12), %rax
leaq (%r15,%rax), %rcx
movq %rcx, (%r14)
cmpb $0x0, (%r15,%rax)
je 0x18d86
movb $0x0, (%rcx)
movq (%r14), %rax
incq %rax
jmp 0x18d88
xorl %eax, %eax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9a47(%rip), %rdi      # 0x227e5
leaq 0x9996(%rip), %rsi      # 0x2273b
leaq 0x9a49(%rip), %rcx      # 0x227f5
movl $0x349, %edx            # imm = 0x349
callq 0x5250
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: io::trim_chars<(char)32, (char)9>::trim(char*&, char*&)
static void trim(char*&str_begin, char*&str_end){
                        while(is_trim_char(*str_begin, trim_char_list...) && str_begin != str_end)
                                ++str_begin;
                        while(is_trim_char(*(str_end-1), trim_char_list...) && str_begin != str_end)
                                --str_end;
                        *str_end = '\0';
                }

// Assembly:
movq (%rdi), %rcx
movzbl (%rcx), %eax
cmpl $0x9, %eax
je 0x18dc6
cmpl $0x20, %eax
jne 0x18dd6
movq (%rsi), %rax
cmpq %rax, %rcx
je 0x18de1
incq %rcx
movq %rcx, (%rdi)
jmp 0x18db9
movq (%rsi), %rax
jmp 0x18de1
decq %rax
movq %rax, (%rsi)
movzbl -0x1(%rax), %ecx
cmpl $0x20, %ecx
je 0x18def
cmpl $0x9, %ecx
jne 0x18df4
cmpq (%rdi), %rax
jne 0x18ddb
movb $0x0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::detail::parse_line<io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>>(char*, char**, std::vector<int, std::allocator<int>> const&)
void parse_line(
                        char*line,
                        char**sorted_col,
                        const std::vector<int>&col_order
                ){
                        for(std::size_t i=0; i<col_order.size(); ++i){
                                if(line == nullptr)
                                        throw ::io::error::too_few_columns();
                                char*col_begin, *col_end;
                                chop_next_column<quote_policy>(line, col_begin, col_end);

                                if(col_order[i] != -1){
                                        trim_policy::trim(col_begin, col_end);
                                        quote_policy::unescape(col_begin, col_end);
                                                               
                                        sorted_col[col_order[i]] = col_begin;
                                }
                        }
                        if(line != nullptr)
                                throw ::io::error::too_many_columns();
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
xorl %ebp, %ebp
movq %rsp, %r12
leaq 0x10(%rsp), %r13
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
sarq $0x2, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rbp
jae 0x19062
testq %rax, %rax
je 0x19076
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x18d45
movq (%rbx), %rax
cmpl $-0x1, (%rax,%rbp,4)
je 0x1905d
movq %r12, %rdi
movq %r13, %rsi
callq 0x18db6
movq (%rsp), %rax
movq (%rbx), %rcx
movslq (%rcx,%rbp,4), %rcx
movq %rax, (%r14,%rcx,8)
incq %rbp
jmp 0x19012
testq %rax, %rax
jne 0x190b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x210, %edi            # imm = 0x210
callq 0x51c0
movq %rax, %rbx
movl $0x210, %edx            # imm = 0x210
movq %rax, %rdi
xorl %esi, %esi
callq 0x5220
orl $-0x1, 0x208(%rbx)
leaq 0x15bc0(%rip), %rax     # 0x2ec60
movq %rax, (%rbx)
leaq 0x15b16(%rip), %rsi     # 0x2ebc0
movq 0x15f1f(%rip), %rdx     # 0x2efd0
movq %rbx, %rdi
callq 0x5610
movl $0x210, %edi            # imm = 0x210
callq 0x51c0
movq %rax, %rbx
movl $0x210, %edx            # imm = 0x210
movq %rax, %rdi
xorl %esi, %esi
callq 0x5220
orl $-0x1, 0x208(%rbx)
leaq 0x15bad(%rip), %rax     # 0x2ec90
movq %rax, (%rbx)
leaq 0x15b1b(%rip), %rsi     # 0x2ec08
jmp 0x190aa
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::CSVReader<15u, io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>, io::throw_on_overflow, io::no_comment>::parse_helper<double, double, double, double, double, double, double, double, double, double, double, double, double, double, double>(unsigned long, double&, double&, double&, double&, double&, double&, double&, double&, double&, double&, double&, double&, double&, double&, double&)
void parse_helper(std::size_t r, T&t, ColType&...cols){                        
                        if(row[r]){
                                try{
                                        try{
                                                ::io::detail::parse<overflow_policy>(row[r], t);
                                        }catch(error::with_column_content&err){
                                                err.set_column_content(row[r]);
                                                throw;
                                        }
                                }catch(error::with_column_name&err){
                                        err.set_column_name(column_names[r].c_str());
                                        throw;
                                }
                        }
                        parse_helper(r+1, cols...);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x1d0(%rdi,%rsi,8), %rdi
testq %rdi, %rdi
je 0x1b1d5
movq %rdx, %rsi
callq 0x192de
movq 0x30(%rsp), %r9
incq %rbx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
pushq 0x80(%rsp)
callq 0x1b2ba
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r15
cmpl $0x2, %r12d
jne 0x1b27b
movq %r15, %rdi
callq 0x5170
movq 0x1d0(%r14,%rbx,8), %rsi
movq %rax, %rdi
callq 0x19228
callq 0x54e0
jmp 0x1b2a2
movq %rdx, %r12
movq %rax, %r15
callq 0x55a0
cmpl $0x1, %r12d
jne 0x1b2aa
movq %r15, %rdi
callq 0x5170
shlq $0x5, %rbx
movq 0x248(%r14,%rbx), %rsi
movq %rax, %rdi
callq 0x18e0e
callq 0x54e0
movq %rax, %r15
callq 0x55a0
movq %r15, %rdi
callq 0x5640
movq %rax, %rdi
callq 0x659a
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::detail::parse_signed_integer<io::set_to_max_on_overflow, int>(char const*, int&)
void parse_signed_integer(const char*col, T&x){
                        if(*col == '-'){
                                ++col;

                                x = 0;
                                while(*col != '\0'){
                                        if('0' <= *col && *col <= '9'){
                                                T y = *col - '0';
                                                if(x < (std::numeric_limits<T>::min()+y)/10){
                                                        overflow_policy::on_underflow(x);
                                                        return;
                                                }
                                                x = 10*x-y;
                                        }else
                                                throw error::no_digit();
                                        ++col;
                                }
                                return;
                        }else if(*col == '+')
                                ++col;
                        parse_unsigned_integer<overflow_policy>(col, x);
                }

// Assembly:
pushq %rbx
movzbl (%rdi), %eax
cmpl $0x2b, %eax
je 0x194bc
cmpl $0x2d, %eax
jne 0x194bf
incq %rdi
xorl %ecx, %ecx
pushq $0xa
popq %r8
movl %ecx, (%rsi)
movb (%rdi), %al
testb %al, %al
je 0x194cb
addb $-0x30, %al
cmpb $0x9, %al
ja 0x194cd
movzbl %al, %r9d
movl $0x80000000, %eax       # imm = 0x80000000
subl %r9d, %eax
xorl %edx, %edx
divl %r8d
negl %eax
cmpl %eax, %ecx
jl 0x194c5
imull $0xa, %ecx, %ecx
subl %r9d, %ecx
incq %rdi
jmp 0x1948c
incq %rdi
popq %rbx
jmp 0x1954b
movl $0x80000000, (%rsi)     # imm = 0x80000000
popq %rbx
retq
movl $0x290, %edi            # imm = 0x290
callq 0x51c0
movq %rax, %rbx
movl $0x290, %edx            # imm = 0x290
movq %rax, %rdi
xorl %esi, %esi
callq 0x5220
orl $-0x1, 0x208(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20c(%rbx)
movups %xmm0, 0x21c(%rbx)
movups %xmm0, 0x22c(%rbx)
movups %xmm0, 0x23c(%rbx)
movups %xmm0, 0x24c(%rbx)
movups %xmm0, 0x25c(%rbx)
movups %xmm0, 0x26c(%rbx)
movups %xmm0, 0x27c(%rbx)
leaq 0x15806(%rip), %rax     # 0x2ed38
movq %rax, (%rbx)
leaq 0x15784(%rip), %rsi     # 0x2ecc0
movq 0x15a8d(%rip), %rdx     # 0x2efd0
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::detail::parse_unsigned_integer<io::set_to_max_on_overflow, int>(char const*, int&)
void parse_unsigned_integer(const char*col, T&x){
                        x = 0;
                        while(*col != '\0'){
                                if('0' <= *col && *col <= '9'){
                                        T y = *col - '0';
                                        if(x > (std::numeric_limits<T>::max()-y)/10){
                                                overflow_policy::on_overflow(x);
                                                return;
                                        }
                                        x = 10*x+y;
                                }else
                                        throw error::no_digit();
                                ++col;
                        }
                }

// Assembly:
pushq %rbx
andl $0x0, (%rsi)
xorl %ecx, %ecx
pushq $0xa
popq %r8
movb (%rdi), %al
testb %al, %al
je 0x19589
addb $-0x30, %al
cmpb $0x9, %al
ja 0x1958b
movzbl %al, %r9d
movl %r9d, %eax
xorl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
xorl %edx, %edx
divl %r8d
cmpl %eax, %ecx
jg 0x19583
imull $0xa, %ecx, %ecx
addl %r9d, %ecx
movl %ecx, (%rsi)
incq %rdi
jmp 0x19555
movl $0x7fffffff, (%rsi)     # imm = 0x7FFFFFFF
popq %rbx
retq
movl $0x290, %edi            # imm = 0x290
callq 0x51c0
movq %rax, %rbx
movl $0x290, %edx            # imm = 0x290
movq %rax, %rdi
xorl %esi, %esi
callq 0x5220
orl $-0x1, 0x208(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20c(%rbx)
movups %xmm0, 0x21c(%rbx)
movups %xmm0, 0x22c(%rbx)
movups %xmm0, 0x23c(%rbx)
movups %xmm0, 0x24c(%rbx)
movups %xmm0, 0x25c(%rbx)
movups %xmm0, 0x26c(%rbx)
movups %xmm0, 0x27c(%rbx)
leaq 0x15748(%rip), %rax     # 0x2ed38
movq %rax, (%rbx)
leaq 0x156c6(%rip), %rsi     # 0x2ecc0
movq 0x159cf(%rip), %rdx     # 0x2efd0
movq %rbx, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/PlainObjectBase.h
// Function: Eigen::internal::conservative_resize_like_impl<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::Matrix<double, -1, -1, 0, -1, -1>, false>::run(Eigen::DenseBase<Eigen::Matrix<double, -1, -1, 0, -1, -1>>&, long, long)
static void run(DenseBase<Derived>& _this, Index rows, Index cols)
  {
    if (_this.rows() == rows && _this.cols() == cols) return;
    EIGEN_STATIC_ASSERT_DYNAMIC_SIZE(Derived)

    if ( ( Derived::IsRowMajor && _this.cols() == cols) || // row-major and we change only the number of rows
         (!Derived::IsRowMajor && _this.rows() == rows) )  // column-major and we change only the number of columns
    {
      internal::check_rows_cols_for_overflow<Derived::MaxSizeAtCompileTime>::run(rows, cols);
      _this.derived().m_storage.conservativeResize(rows*cols,rows,cols);
    }
    else
    {
      // The storage order does not allow us to use reallocation.
      typename Derived::PlainObject tmp(rows,cols);
      const Index common_rows = (std::min)(rows, _this.rows());
      const Index common_cols = (std::min)(cols, _this.cols());
      tmp.block(0,0,common_rows,common_cols) = _this.block(0,0,common_rows,common_cols);
      _this.derived().swap(tmp);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq %rsi, 0x8(%rdi)
jne 0x196d7
movq %rdx, %r14
cmpq %rdx, 0x10(%rbx)
je 0x19773
movq %rsi, %r15
testq %rsi, %rsi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x196b6
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %r14
cmpq %r15, %rax
jge 0x196b6
callq 0x65cc
movq %r14, %rsi
imulq %r15, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x19798
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x197c8
movq (%r14), %r14
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %r14, %rax
cmovlq %rax, %r14
movq (%r15), %r15
cmpq %r15, %rcx
cmovlq %rcx, %r15
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %r15, %r9
callq 0x19884
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq %r15, %r9
callq 0x19884
leaq 0x30(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x19968
movq (%rbx), %rdi
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
movq %rdi, 0x8(%rsp)
movups 0x10(%rsp), %xmm0
movups 0x8(%rbx), %xmm1
movups %xmm0, 0x8(%rbx)
movups %xmm1, 0x10(%rsp)
callq 0x5430
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x19782
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x5430
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_realloc_new_auto<double, true>(double*, unsigned long, unsigned long)
inline T* conditional_aligned_realloc_new_auto(T* pts, size_t new_size, size_t old_size)
{
  check_size_for_overflow<T>(new_size);
  check_size_for_overflow<T>(old_size);
  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
    destruct_elements_of_array(pts+new_size, old_size-new_size);
  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
    construct_elements_of_array(result+old_size, new_size-old_size);
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x1fffffffffffffff, %r12 # imm = 0x1FFFFFFFFFFFFFFF
movq %rsi, %rax
shrq $0x3d, %rax
je 0x19829
callq 0x65cc
cmpq %r12, %rbx
jbe 0x19833
callq 0x65cc
shlq $0x3, %r14
shlq $0x3, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19854
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/Orbit.cpp
// Function: dcmPQW2ECI(Orbit)
Matrix3d dcmPQW2ECI(Orbit element){
    Matrix3d dcmPQW2ECI_ = Matrix3d::Zero();
    double Omega = element.raan;
    double omega = element.arg_perigee;
    double i = element.inclination;
    double cO = cos(Omega); double sO = sin(Omega);
    double co = cos(omega); double so = sin(omega);
    double ci = cos(i);     double si = sin(i);
    dcmPQW2ECI_ << cO*co-sO*ci*so, -cO*so-sO*ci*co,  sO*si,
    sO*co+cO*ci*so, -sO*so+cO*ci*co, -cO*si,
    si*so,           si*co,           ci;
    return dcmPQW2ECI_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x1c968
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1caf6
movsd 0xd8(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0xe8(%rsp), %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0xf0(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movaps %xmm1, %xmm0
callq 0x5680
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x50e0
movaps %xmm0, 0x30(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x5680
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
callq 0x5680
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x48(%rsp)
movsd (%rsp), %xmm0
callq 0x50e0
movsd %xmm0, (%rsp)
movapd 0x30(%rsp), %xmm1
xorpd 0x2d21(%rip), %xmm1     # 0x1f010
movsd 0x8(%rsp), %xmm0
movapd %xmm1, 0x50(%rsp)
mulsd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm5
movapd %xmm5, %xmm1
mulsd %xmm0, %xmm1
movapd 0x20(%rsp), %xmm3
movapd %xmm3, %xmm2
movq %rbx, (%r14)
andq $0x0, 0x8(%r14)
movsd 0x18(%rsp), %xmm4
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
pushq $0x1
popq %rax
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movsd %xmm2, (%rbx)
mulsd %xmm4, %xmm0
movapd %xmm3, %xmm1
mulsd %xmm5, %xmm1
subsd %xmm1, %xmm0
leaq 0x90(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x98(%rsp), %rdi
callq 0x1c988
movapd 0x30(%rsp), %xmm0
mulsd (%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c988
movsd 0x8(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
movsd %xmm1, 0x8(%rsp)
mulsd %xmm1, %xmm0
movapd 0x30(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd %xmm0, %xmm1
leaq 0x80(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rax, %rdi
callq 0x1c988
movsd 0x8(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movapd 0x50(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
leaq 0x78(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c988
movapd 0x20(%rsp), %xmm0
xorpd 0x2c11(%rip), %xmm0     # 0x1f010
mulsd (%rsp), %xmm0
leaq 0x70(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c988
movsd 0x10(%rsp), %xmm0
mulsd (%rsp), %xmm0
leaq 0x68(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c988
movsd 0x18(%rsp), %xmm0
mulsd (%rsp), %xmm0
leaq 0x60(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1c988
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x1c988
leaq 0x98(%rsp), %rdi
callq 0x1ca30
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r14
retq
jmp 0x1c481
jmp 0x1c481
jmp 0x1c481
jmp 0x1c481
jmp 0x1c481
jmp 0x1c481
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x1ca30
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/Orbit.cpp
// Function: posOrbit2ECI(Orbit)
Vector3d posOrbit2ECI(Orbit element){
    double p = element.semi_latus_rectum;
    double nu = element.true_anomaly;
    double e = element.eccentricity;
    Vector3d posPQW_;
    Vector3d posECI_;
    posPQW_ << p*cos(nu)/(1+e*cos(nu)),
    p*sin(nu)/(1+e*cos(nu)),
    0;
    posECI_ = dcmPQW2ECI(element) * posPQW_;
    return posECI_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %rbx
movsd 0x1c0(%rsp), %xmm0
movsd %xmm0, 0x98(%rsp)
movsd 0x180(%rsp), %xmm0
movsd %xmm0, 0xa8(%rsp)
movsd 0x1b8(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
callq 0x5680
mulsd 0x98(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0xa0(%rsp), %xmm0
callq 0x5680
mulsd 0xa8(%rsp), %xmm0
addsd 0x2b4a(%rip), %xmm0     # 0x1f060
movsd 0xb0(%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0x130(%rsp), %r12
leaq 0xe8(%rsp), %r14
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
pushq $0x1
popq %rax
movq %rax, 0x10(%r14)
movq %rax, 0x18(%r14)
movsd %xmm1, (%r12)
movsd 0xa0(%rsp), %xmm0
callq 0x50e0
mulsd 0x98(%rsp), %xmm0
movsd %xmm0, 0x98(%rsp)
movsd 0xa0(%rsp), %xmm0
callq 0x5680
mulsd 0xa8(%rsp), %xmm0
addsd 0x2ad5(%rip), %xmm0     # 0x1f060
movsd 0x98(%rsp), %xmm1
divsd %xmm0, %xmm1
leaq 0xc0(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %r14, %rdi
callq 0xfd60
leaq 0xb8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0xfd60
leaq 0x170(%rsp), %r14
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
callq 0xfe08
pushq $0x12
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
callq 0x1c229
leaq 0xc0(%rsp), %rsi
movq %r15, (%rsi)
movq %r12, 0x8(%rsi)
movq %rbx, %rdi
callq 0x15e70
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c617
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xfe08
movq %rbx, %rdi
callq 0x5640