LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x250(%rbp)
movq %rdi, %rax
movq %rax, -0x248(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19a3f(%rip), %rsi     # 0x58f8e
callq 0x6560
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3f5f8
callq 0x6090
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x40560
leaq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x405e0
jmp 0x3f587
leaq -0x128(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x40600
jmp 0x3f599
movl $0x210, %edi            # imm = 0x210
callq 0x6250
movq %rax, %rdi
movq %rdi, -0x258(%rbp)
leaq -0x230(%rbp), %rsi
callq 0x40640
movq -0x258(%rbp), %rdi
leaq 0x39259(%rip), %rsi     # 0x78820
leaq 0x10e2(%rip), %rdx      # 0x406b0
callq 0x6760
jmp 0x3f66c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x406b0
jmp 0x3f660
movl $0x10, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq -0x18(%rbp), %rsi
callq 0x406d0
jmp 0x3f61a
movq -0x260(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x40730
movq -0x248(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x260(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
movl $0x10, %esi
callq 0x6490
movq -0x238(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x30(%rbp)
addq $0x30, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3eaf0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rdi)
movl -0x14(%rbp), %eax
movl %eax, 0x28(%rdi)
movl $0xffffffff, 0x2c(%rdi) # imm = 0xFFFFFFFF
addq $0x88, %rdi
callq 0x6260
leaq -0x28(%rbp), %rdi
callq 0x3eb30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x208(%rax)
je 0x408c5
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0x108, %rcx            # imm = 0x108
movq %rcx, -0x18(%rbp)
movl 0x208(%rax), %edi
callq 0x6180
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq %rax, %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x186d5(%rip), %rdx     # 0x58f91
movb $0x0, %al
callq 0x66c0
jmp 0x408ea
movq -0x10(%rbp), %rcx
movq %rcx, %rdi
addq $0x8, %rdi
addq $0x108, %rcx            # imm = 0x108
movl $0x100, %esi            # imm = 0x100
leaq 0x186d3(%rip), %rdx     # 0x58fb6
movb $0x0, %al
callq 0x66c0
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x30, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3eaf0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x58, %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
callq 0x41f70
jmp 0x41db3
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
callq 0x41fc0
testb $0x1, %al
jne 0x41dc6
jmp 0x41e0b
movq -0x48(%rbp), %rsi
addq $0x18, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x41fe0
movq -0x50(%rbp), %rdi
callq 0x64a0
jmp 0x41de6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x41e27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3eb70
jmp 0x41e27
movq -0x48(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3eb30
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0x3eb30
movq -0x28(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x421d0
jmp 0x421ef
leaq 0x16eb7(%rip), %rdi     # 0x5908e
leaq 0x16e06(%rip), %rsi     # 0x58fe4
movl $0x349, %edx            # imm = 0x349
leaq 0x16eb4(%rip), %rcx     # 0x5909e
callq 0x62f0
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x42790
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x42248
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x42264
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x20, %esi
movl $0x9, %edx
movsbl (%rax), %edi
callq 0x427e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x422a7
jmp 0x422bb
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x422c4
jmp 0x422d4
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x42280
jmp 0x422d6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl $0x20, %esi
movl $0x9, %edx
movsbl -0x1(%rax), %edi
callq 0x427e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x12(%rbp)
jne 0x422fe
jmp 0x42312
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x4231b
jmp 0x4232b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
jmp 0x422d6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/csv.h
// Function: void io::CSVReader<2u, io::trim_chars<(char)32, (char)9>, io::no_quote_escape<(char)44>, io::throw_on_overflow, io::no_comment>::parse_helper<double, double>(unsigned long, 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
cmpq $0x0, 0x1d0(%rax,%rcx,8)
je 0x430be
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x1d0(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x43310
jmp 0x42fee
jmp 0x430a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x43055
movq -0x28(%rbp), %rdi
callq 0x61d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x1d0(%rax,%rcx,8), %rsi
callq 0x43340
jmp 0x43036
callq 0x6630
jmp 0x430ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x66f0
jmp 0x43053
jmp 0x43055
movl -0x2c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x430d9
movq -0x28(%rbp), %rdi
callq 0x61d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x1e0(%rax,%rcx), %rdi
callq 0x61e0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x42400
callq 0x6630
jmp 0x430ea
jmp 0x430bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x66f0
jmp 0x430ba
jmp 0x430d9
jmp 0x430be
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
callq 0x43380
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x67a0
movq %rax, %rdi
callq 0x8700
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x438d4
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x438d2
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x43861
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x43861
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0x439d0
addl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0x4384f
movq -0x10(%rbp), %rdi
callq 0x439e0
jmp 0x438fb
movq -0x10(%rbp), %rax
imull $0xa, (%rax), %ecx
subl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x438c1
movl $0x290, %edi            # imm = 0x290
movq %rdi, -0x40(%rbp)
callq 0x6250
movq -0x40(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorl %esi, %esi
callq 0x62a0
movq -0x30(%rbp), %rdi
callq 0x43910
jmp 0x43893
movq -0x38(%rbp), %rdi
leaq 0x3540a(%rip), %rsi     # 0x78ca8
leaq 0x10b(%rip), %rdx       # 0x439b0
callq 0x6760
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x6350
jmp 0x43901
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x437e6
jmp 0x438fb
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x438ec
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x438ee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x43a00
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x43b06
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x43a95
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x43a95
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
callq 0x43b20
subl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jle 0x43a83
movq -0x10(%rbp), %rdi
callq 0x43b30
jmp 0x43b06
movq -0x10(%rbp), %rax
imull $0xa, (%rax), %ecx
addl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x43af5
movl $0x290, %edi            # imm = 0x290
movq %rdi, -0x40(%rbp)
callq 0x6250
movq -0x40(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
xorl %esi, %esi
callq 0x62a0
movq -0x30(%rbp), %rdi
callq 0x43910
jmp 0x43ac7
movq -0x38(%rbp), %rdi
leaq 0x351d6(%rip), %rsi     # 0x78ca8
leaq -0x129(%rip), %rdx      # 0x439b0
callq 0x6760
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x6350
jmp 0x43b0c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x43a1a
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x8(%rbp)
jbe 0x44011
callq 0x89b0
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, -0x10(%rbp)
jbe 0x4402e
callq 0x89b0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
movq -0x28(%rbp), %rdx
shlq $0x3, %rdx
callq 0x44060
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movsd 0x50(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x1d670
movq -0x1d8(%rbp), %rdi
callq 0x1d670
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x1d0(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6810
movaps %xmm0, %xmm1
movsd -0x1d0(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x1b8(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x1c8(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6810
movsd -0x1c8(%rbp), %xmm1
movq -0x1c0(%rbp), %rsi
movaps %xmm0, %xmm2
movsd -0x1b8(%rbp), %xmm0
mulsd %xmm2, %xmm1
movsd 0x8a40(%rip), %xmm2     # 0x52040
movsd %xmm2, -0x1a0(%rbp)
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x198(%rbp)
leaq -0x60(%rbp), %rdx
callq 0x1e1e0
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x1b0(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6120
movaps %xmm0, %xmm1
movsd -0x1b0(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x190(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x1a8(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6810
movsd -0x1a8(%rbp), %xmm1
movsd -0x1a0(%rbp), %xmm2
movq -0x198(%rbp), %rdi
movaps %xmm0, %xmm3
movsd -0x190(%rbp), %xmm0
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x1e220
movq %rax, -0x188(%rbp)
jmp 0x496b3
movq -0x188(%rbp), %rdi
movq $0x0, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x1e220
jmp 0x496cd
leaq -0x58(%rbp), %rdi
callq 0x1e390
movq -0x1e0(%rbp), %rsi
leaq -0x180(%rbp), %rdi
movl $0x90, %edx
callq 0x63b0
movq %rsp, %rdi
movl $0x12, %ecx
leaq -0x180(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0xf0(%rbp), %rdi
callq 0x491f0
leaq -0xa8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x20520
movq -0x1d8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x210b0
movq -0x1e8(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1e390
movq -0x70(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/Orbit.cpp
// Function: velOrbit2ECI(Orbit)
Vector3d velOrbit2ECI(Orbit element){
    double p = element.semi_latus_rectum;
    double nu = element.true_anomaly;
    double e = element.eccentricity;
    double mu = element.mu;
    Vector3d velPQW_;
    Vector3d velECI_;
    velPQW_ << -sqrt(mu/p)*sin(nu),
    sqrt(mu/p)*(e+cos(nu)),
    0;
    velECI_ = dcmPQW2ECI(element) * velPQW_;
    return velECI_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movsd 0x50(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
callq 0x1d670
movq -0x1c0(%rbp), %rdi
callq 0x1d670
movsd -0x28(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x6390
movaps 0x9848(%rip), %xmm1     # 0x53040
pxor %xmm1, %xmm0
movsd %xmm0, -0x1b0(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6120
movq -0x1b8(%rbp), %rsi
movaps %xmm0, %xmm1
movsd -0x1b0(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
leaq -0x68(%rbp), %rdx
callq 0x1e1e0
movsd -0x28(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
callq 0x6390
movsd %xmm0, -0x198(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x1a8(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6810
movsd -0x1a8(%rbp), %xmm1
movq -0x1a0(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x198(%rbp), %xmm0
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x1e220
movq %rax, -0x190(%rbp)
jmp 0x498a8
movq -0x190(%rbp), %rdi
movq $0x0, -0x88(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x1e220
jmp 0x498c8
leaq -0x60(%rbp), %rdi
callq 0x1e390
movq -0x1c8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movl $0x90, %edx
callq 0x63b0
movq %rsp, %rdi
movl $0x12, %ecx
leaq -0x188(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0xf8(%rbp), %rdi
callq 0x491f0
leaq -0xb0(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x20520
movq -0x1c0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x210b0
movq -0x1d0(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1e390
movq -0x78(%rbp), %rdi
callq 0x67a0
nop
// File: istellartech[P]OpenTsiolkovsky/src/Orbit.cpp
// Function: success_orbit(Orbit)
bool success_orbit(Orbit element){
    double const earth_radius = 6378.137; // 地球半径 km
    Vector3d posECI_check;
    element.true_anomaly = 0;
    posECI_check = posOrbit2ECI(element);
    if (posECI_check.norm() > earth_radius) {
        return true;
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
leaq 0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movsd 0xfdea(%rip), %xmm0     # 0x59768
movsd %xmm0, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1d670
movq -0xd8(%rbp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rsi)
leaq -0xd0(%rbp), %rdi
movl $0x90, %edx
callq 0x63b0
movq %rsp, %rdi
movl $0x12, %ecx
leaq -0xd0(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq -0x40(%rbp), %rdi
callq 0x49530
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x20420
leaq -0x28(%rbp), %rdi
callq 0x205d0
movsd 0xfd83(%rip), %xmm1     # 0x59768
ucomisd %xmm1, %xmm0
jbe 0x499f1
movb $0x1, -0x1(%rbp)
jmp 0x499f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/Orbit.cpp
// Function: julian_day(int, int, int, int, int, double)
double julian_day(int year, int mon, int day, int hr, int minute, double sec){
    /* Input UTC
     *  inputs          description                    range / units
     *    year        - year                           1900 .. 2100
     *    mon         - month                          1 .. 12
     *    day         - day                            1 .. 28,29,30,31
     *    hr          - universal time hour            0 .. 23
     *    min         - universal time min             0 .. 59
     *    sec         - universal time sec             0.0 .. 59.999
     *  outputs       :
     *    jd          - julian date                    days from 4713 bc
     * cf. sgp4ext.cpp */
    double jd = 367.0 * year - floor((7 * (year + floor((mon + 9) / 12.0))) * 0.25) +
                floor( 275 * mon / 9.0 ) + day + 1721013.5 +
                ((sec / 60.0 + minute) / 60.0 + hr) / 24.0;  // ut in days
    return jd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x8(%rbp), %eax
addl $0x9, %eax
cvtsi2sd %eax, %xmm0
movsd 0xfd55(%rip), %xmm1     # 0x597a8
divsd %xmm1, %xmm0
callq 0x6730
movsd -0x40(%rbp), %xmm1
addsd %xmm0, %xmm1
movsd 0xfd33(%rip), %xmm0     # 0x597a0
mulsd %xmm1, %xmm0
movsd 0xfd1f(%rip), %xmm1     # 0x59798
mulsd %xmm1, %xmm0
callq 0x6730
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0xfce7(%rip), %xmm2     # 0x59790
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
imull $0x113, -0x8(%rbp), %eax # imm = 0x113
cvtsi2sd %eax, %xmm0
movsd 0xfcbf(%rip), %xmm1     # 0x59788
divsd %xmm1, %xmm0
callq 0x6730
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
addsd %xmm1, %xmm0
movsd 0xfc91(%rip), %xmm1     # 0x59780
addsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0xfc78(%rip), %xmm2     # 0x59778
divsd %xmm2, %xmm1
cvtsi2sdl -0x14(%rbp), %xmm2
addsd %xmm2, %xmm1
movsd 0xfc63(%rip), %xmm2     # 0x59778
divsd %xmm2, %xmm1
cvtsi2sdl -0x10(%rbp), %xmm2
addsd %xmm2, %xmm1
movsd 0xfc46(%rip), %xmm2     # 0x59770
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/Orbit.hpp
// Function: Orbit::Orbit(double, double, double, double, double, double)
Orbit(double a=1, double e=0, double i=0,
          double Omega=0, double omega=0, double nu=0){
        semi_major = a;
        eccentricity = e;
        raan = Omega;
        arg_perigee = omega;
        true_anomaly = nu;
        semi_latus_rectum = a * (1-e*e);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd %xmm5, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd 0xfbde(%rip), %xmm0     # 0x59760
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x58(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x48(%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm1
movsd 0x8456(%rip), %xmm2     # 0x52040
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rax)
popq %rbp
retq
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: dcmECI2ECEF(double)
Matrix3d dcmECI2ECEF(double second){
    double omega = 7.292115e-5; // 地球の自転角速度[rad/s]
    double theta = omega * second;
    Matrix3d dcm;
    dcm << cos(theta), sin(theta), 0.0,
          -sin(theta), cos(theta), 0.0,
           0.0,        0.0,        1.0;
    return dcm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movabsq $0x3f131da7d157db65, %rax # imm = 0x3F131DA7D157DB65
movq %rax, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x1dbe0
movsd -0x20(%rbp), %xmm0
callq 0x6810
movq -0xb0(%rbp), %rsi
movsd %xmm0, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x48(%rbp), %rdx
callq 0x49f30
movsd -0x20(%rbp), %xmm0
callq 0x6120
movq -0xa8(%rbp), %rdi
movsd %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x49f70
movq %rax, -0xa0(%rbp)
jmp 0x4abcd
movq -0xa0(%rbp), %rdi
movq $0x0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x49f70
movq %rax, -0xc0(%rbp)
jmp 0x4abee
movsd -0x20(%rbp), %xmm0
callq 0x6120
movq -0xc0(%rbp), %rdi
movaps 0x843a(%rip), %xmm1     # 0x53040
pxor %xmm1, %xmm0
movlpd %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x49f70
movq %rax, -0xc8(%rbp)
jmp 0x4ac21
movsd -0x20(%rbp), %xmm0
callq 0x6810
movq -0xc8(%rbp), %rdi
movsd %xmm0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x49f70
movq %rax, -0xd0(%rbp)
jmp 0x4ac49
movq -0xd0(%rbp), %rdi
movq $0x0, -0x80(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x49f70
movq %rax, -0xd8(%rbp)
jmp 0x4ac6a
movq -0xd8(%rbp), %rdi
movq $0x0, -0x88(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x49f70
movq %rax, -0xe0(%rbp)
jmp 0x4ac91
movq -0xe0(%rbp), %rdi
movq $0x0, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x49f70
movq %rax, -0xe8(%rbp)
jmp 0x4acb8
movq -0xe8(%rbp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rsi
callq 0x49f70
jmp 0x4acde
leaq -0x40(%rbp), %rdi
callq 0x4a0e0
movq -0xb8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4a0e0
movq -0x58(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: vel_ECEF_NEDframe(Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector3d vel_ECEF_NEDframe(Matrix3d dcmECI2NED_, Vector3d vel_ECI_ECIframe_, Vector3d pos_ECI_){
    double omega = 7.292115e-5; // 地球の自転角速度[rad]
    Matrix3d omegaECI2ECEF_;    // 角速度テンソル angular velocity tensorß
    omegaECI2ECEF_ << 0.0,   -omega, 0.0,
                      omega, 0.0,    0.0,
                      0.0,   0.0,    0.0;
    return dcmECI2NED_ * (vel_ECI_ECIframe_ - omegaECI2ECEF_ * pos_ECI_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rcx, -0x1a8(%rbp)
movq %rdx, -0x1a0(%rbp)
movq %rsi, -0x198(%rbp)
movq %rdi, -0x190(%rbp)
movq %rdi, %rax
movq %rax, -0x188(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movabsq $0x3f131da7d157db65, %rax # imm = 0x3F131DA7D157DB65
movq %rax, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1dbe0
movq -0x180(%rbp), %rsi
movq $0x0, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0x178(%rbp)
leaq -0x98(%rbp), %rdx
callq 0x49f30
movq -0x178(%rbp), %rdi
movaps 0x7af7(%rip), %xmm1     # 0x53040
movsd -0x28(%rbp), %xmm0
pxor %xmm1, %xmm0
movlpd %xmm0, -0xa0(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x49f70
movq %rax, -0x170(%rbp)
jmp 0x4b56f
movq -0x170(%rbp), %rdi
movq $0x0, -0xb8(%rbp)
leaq -0xb8(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1b0(%rbp)
jmp 0x4b596
movq -0x1b0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1b8(%rbp)
jmp 0x4b5af
movq -0x1b8(%rbp), %rdi
movq $0x0, -0xc0(%rbp)
leaq -0xc0(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1c0(%rbp)
jmp 0x4b5d6
movq -0x1c0(%rbp), %rdi
movq $0x0, -0xc8(%rbp)
leaq -0xc8(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1c8(%rbp)
jmp 0x4b5fd
movq -0x1c8(%rbp), %rdi
movq $0x0, -0xd0(%rbp)
leaq -0xd0(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1d0(%rbp)
jmp 0x4b624
movq -0x1d0(%rbp), %rdi
movq $0x0, -0xd8(%rbp)
leaq -0xd8(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1d8(%rbp)
jmp 0x4b64b
movq -0x1d8(%rbp), %rdi
movq $0x0, -0xe0(%rbp)
leaq -0xe0(%rbp), %rsi
callq 0x49f70
jmp 0x4b66b
leaq -0x90(%rbp), %rdi
callq 0x4a0e0
movq -0x1a8(%rbp), %rdx
leaq -0x168(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x20520
movq -0x1a0(%rbp), %rsi
leaq -0x140(%rbp), %rdi
leaq -0x168(%rbp), %rdx
callq 0x4d780
movq -0x198(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x140(%rbp), %rdx
callq 0x4d730
leaq -0x118(%rbp), %rdi
callq 0x38610
movq -0x190(%rbp), %rdi
movq %rax, %rsi
callq 0x1f0e0
movq -0x188(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4a0e0
movq -0xa8(%rbp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: vel_wind_NEDframe(double, double)
Vector3d vel_wind_NEDframe(double wind_speed, double wind_direction){
    Vector3d vel;
    vel[0] = - wind_speed * cos(deg2rad(wind_direction));
    vel[1] = - wind_speed * sin(deg2rad(wind_direction));
    vel[2] = 0;
    return vel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
callq 0x1d670
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x1e000
callq 0x6810
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1de40
movsd -0x40(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x1e000
callq 0x6120
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, %esi
callq 0x1de40
movsd -0x30(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movsd %xmm0, (%rax)
movl $0x2, %esi
callq 0x1de40
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: dcmNED2BODY(double, double)
Matrix3d dcmNED2BODY(double azimuth_rad, double elevation_rad){
    Matrix3d dcm;
    double az = azimuth_rad;
    double el = elevation_rad;
    /*
    dcm <<  cos(el)*cos(az), cos(el)*sin(az), -sin(el),
    -sin(az),                cos(az),          0,
    sin(el)*cos(az),         sin(el)*sin(az),  cos(el);
    */
    dcm = dcmNED2BODY(az, el, 0.0);
    return dcm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
callq 0x1dbe0
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
leaq -0x70(%rbp), %rdi
xorps %xmm2, %xmm2
callq 0x4bb40
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x20370
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: azimuth_elevation(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector2d azimuth_elevation(Vector3d vel_BODY_NEDframe){
    double north  = vel_BODY_NEDframe[0];
    double east = vel_BODY_NEDframe[1];
    double down = vel_BODY_NEDframe[2];
    double azimuth = pi/2.0 - atan2(north, east);
    double elevation = atan2(-down, sqrt(north * north + east * east));
    Vector2d azel;
    azel[0] = azimuth;
    azel[1] = elevation;
    return azel;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq %rax, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1de40
movq -0x68(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, %esi
callq 0x1de40
movq -0x68(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x2, %esi
callq 0x1de40
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x60c0
movaps %xmm0, %xmm1
movsd 0x6e10(%rip), %xmm0     # 0x52e70
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x6390
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
callq 0x60c0
movq -0x50(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
callq 0x1d690
movq -0x50(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x20050
movsd -0x58(%rbp), %xmm0
movq -0x50(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x1, %esi
callq 0x20050
movsd -0x48(%rbp), %xmm0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movsd %xmm0, (%rcx)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: azimuth_elevation_roll(Eigen::Matrix<double, 3, 3, 0, 3, 3>)
Vector3d azimuth_elevation_roll(Matrix3d dcmNED2BODY_){
    Vector3d azelro = dcmNED2BODY_.transpose().eulerAngles(2, 1, 0);
    double az_rad = azelro[0];
    double el_rad = azelro[1];
    double ro_rad = azelro[2];

    if (el_rad > deg2rad(90.0)) {
        ro_rad += deg2rad(180.0);
        az_rad += deg2rad(180.0);
        el_rad = deg2rad(180.0) - el_rad;
    } else if (el_rad < deg2rad(-90.0)) {
        ro_rad += deg2rad(180.0);
        az_rad += deg2rad(180.0);
        el_rad = deg2rad(-180.0) - el_rad;
    }

    if (ro_rad > deg2rad(180.0)){
        ro_rad -= deg2rad(360.0);
    }

    return  Vector3d(az_rad, el_rad, ro_rad);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rax, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x20450
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %edx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x4d7f0
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1de40
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1de40
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
callq 0x1de40
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x6c94(%rip), %xmm0     # 0x52e58
callq 0x1e000
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4c21e
movsd 0x6c61(%rip), %xmm0     # 0x52e40
callq 0x1e000
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x6c4a(%rip), %xmm0     # 0x52e40
callq 0x1e000
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x6c33(%rip), %xmm0     # 0x52e40
callq 0x1e000
subsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x4c287
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd 0xd890(%rip), %xmm0     # 0x59ac0
callq 0x1e000
movsd -0x70(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4c285
movsd 0x6bf8(%rip), %xmm0     # 0x52e40
callq 0x1e000
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd 0x6be1(%rip), %xmm0     # 0x52e40
callq 0x1e000
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0xd852(%rip), %xmm0     # 0x59ac8
callq 0x1e000
subsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x4c287
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd 0x6ba7(%rip), %xmm0     # 0x52e40
callq 0x1e000
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4c2ca
movsd 0xd81c(%rip), %xmm0     # 0x59ad0
callq 0x1e000
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x4a220
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: vel_ECI_ECIframe(Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::Matrix<double, 3, 1, 0, 3, 1>, Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector3d vel_ECI_ECIframe(Matrix3d dcmNED2ECI_, Vector3d vel_ECEF_NEDframe_, Vector3d posECI_){
    double omega = 7.292115e-5; // 地球の自転角速度[rad]
    Matrix3d omegaECI2ECEF_;    // 角速度テンソル angular velocity tensorß
    omegaECI2ECEF_ << 0.0,   -omega, 0.0,
                      omega, 0.0,    0.0,
                      0.0,   0.0,    0.0;
    return dcmNED2ECI_ * vel_ECEF_NEDframe_ + omegaECI2ECEF_ * posECI_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rcx, -0x1a8(%rbp)
movq %rdx, -0x1a0(%rbp)
movq %rsi, -0x198(%rbp)
movq %rdi, -0x190(%rbp)
movq %rdi, %rax
movq %rax, -0x188(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movabsq $0x3f131da7d157db65, %rax # imm = 0x3F131DA7D157DB65
movq %rax, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x1dbe0
movq -0x180(%rbp), %rsi
movq $0x0, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0x178(%rbp)
leaq -0x98(%rbp), %rdx
callq 0x49f30
movq -0x178(%rbp), %rdi
movaps 0x6917(%rip), %xmm1     # 0x53040
movsd -0x28(%rbp), %xmm0
pxor %xmm1, %xmm0
movlpd %xmm0, -0xa0(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0x49f70
movq %rax, -0x170(%rbp)
jmp 0x4c74f
movq -0x170(%rbp), %rdi
movq $0x0, -0xb8(%rbp)
leaq -0xb8(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1b0(%rbp)
jmp 0x4c776
movq -0x1b0(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1b8(%rbp)
jmp 0x4c78f
movq -0x1b8(%rbp), %rdi
movq $0x0, -0xc0(%rbp)
leaq -0xc0(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1c0(%rbp)
jmp 0x4c7b6
movq -0x1c0(%rbp), %rdi
movq $0x0, -0xc8(%rbp)
leaq -0xc8(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1c8(%rbp)
jmp 0x4c7dd
movq -0x1c8(%rbp), %rdi
movq $0x0, -0xd0(%rbp)
leaq -0xd0(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1d0(%rbp)
jmp 0x4c804
movq -0x1d0(%rbp), %rdi
movq $0x0, -0xd8(%rbp)
leaq -0xd8(%rbp), %rsi
callq 0x49f70
movq %rax, -0x1d8(%rbp)
jmp 0x4c82b
movq -0x1d8(%rbp), %rdi
movq $0x0, -0xe0(%rbp)
leaq -0xe0(%rbp), %rsi
callq 0x49f70
jmp 0x4c84b
leaq -0x90(%rbp), %rdi
callq 0x4a0e0
movq -0x198(%rbp), %rsi
movq -0x1a0(%rbp), %rdx
leaq -0x140(%rbp), %rdi
callq 0x20520
movq -0x1a8(%rbp), %rdx
leaq -0x168(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x20520
leaq -0x118(%rbp), %rdi
leaq -0x140(%rbp), %rsi
leaq -0x168(%rbp), %rdx
callq 0x4e1d0
movq -0x190(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x4e240
movq -0x188(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4a0e0
movq -0xa8(%rbp), %rdi
callq 0x67a0
nop
// File: istellartech[P]OpenTsiolkovsky/src/coordinate_transform.cpp
// Function: posECI_init(Eigen::Matrix<double, 3, 1, 0, 3, 1>)
Vector3d posECI_init(Vector3d posLLH_){
    Vector3d posECEF_;
    double second = 0.0;
    posECEF_ = posECEF(posLLH_);
    return posECI(posECEF_, second);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1d670
movq -0x90(%rbp), %rsi
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1f0e0
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4c340
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x20420
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1f0e0
movq -0x88(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
leaq -0x78(%rbp), %rsi
callq 0x4c5e0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)