LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::altitude_with_variation_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
Air Air::altitude_with_variation_table(double altitude, MatrixXd variation_table){
    // Pseudo constructor.
    // Enter altitude and variation ratio air density table to calculate air density
    Air air = Air::altitude(altitude);
    double coef = Air::coef_density_variance_table(altitude, variation_table);
    air.density = air.density * (1.0 + coef);
    return air;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movsd %xmm0, (%rsp)
callq 0x5b4c
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rcx
movq %rcx, %rsi
imulq %rdx, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6a8e
movq %r15, %rdi
movq %r14, %rsi
callq 0x6afc
leaq 0x8(%rsp), %rsi
movsd (%rsp), %xmm0
callq 0x6336
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x5460
movsd (%rsp), %xmm0
addsd 0x20d0f(%rip), %xmm0    # 0x27010
mulsd 0x118(%rbx), %xmm0
movsd %xmm0, 0x118(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6320
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0x5460
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: Air::coef_density_variance_table(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>)
double Air::coef_density_variance_table(double altitude, MatrixXd variation_table){
    // variation table : [altitude[m], air density variation[percent]
    vector<double> altitude_ref;
    vector<double> variation_ref;
    int len = variation_table.rows();

    altitude_ref.resize(len);
    variation_ref.resize(len);

    for(int i=0; i<len; i++){
        altitude_ref[i] = variation_table(i, 0);
        variation_ref[i] = variation_table(i, 1);
    }
    
    double percent_of_density_with_alt = linear_interp1_from_y(altitude, variation_ref, altitude_ref);

    return percent_of_density_with_alt / 100;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rsi), %r15
movslq %r15d, %r14
movq %r14, %rsi
callq 0x6a5c
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x6a5c
testl %r15d, %r15d
jle 0x63f2
movq 0x8(%rbx), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
xorl %esi, %esi
testq %rax, %rax
movl $0x0, %edi
cmovgq %rax, %rdi
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
shlq $0x3, %rax
cmpq %rsi, %rdi
je 0x64a3
movq 0x10(%rbx), %r9
testq %r9, %r9
jle 0x64a3
movq (%rbx), %r8
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%rcx,%rsi,8)
cmpq $0x1, %r9
je 0x64a3
addq %rax, %r8
movsd (%r8,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %r15
jne 0x63ae
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x69dc
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x69dc
leaq 0x50(%rsp), %rdi
leaq 0x68(%rsp), %rbx
movsd 0x8(%rsp), %xmm0
movq %rbx, %rsi
callq 0x6519
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6443
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x645a
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6471
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x6488
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movsd 0x8(%rsp), %xmm0
divsd 0x20b82(%rip), %xmm0    # 0x27018
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21223(%rip), %rdi     # 0x276cd
leaq 0x21251(%rip), %rsi     # 0x27702
leaq 0x21276(%rip), %rcx     # 0x2772e
movl $0x151, %edx            # imm = 0x151
callq 0x5250
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x64e3
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
jmp 0x64e3
jmp 0x64e0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x64fa
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x6511
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/air.cpp
// Function: linear_interp1_from_y(double, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
double linear_interp1_from_y(double y, vector<double> x_array, vector<double> y_array){
    // linear interpolattion with same number of x_array and y_array from y-axis
    // not extrapolation, It has the same value as the outermost point.
    // @params y: y component of the data you want to obtain
    // @params x_array The x component of the original data
    // @params y_array The x component of the original data
    // @return x(double) interpolated value
    double x = 0.0;
    double alpha = 0.0;
    for (int i = 0; i < y_array.size()-1; i++) {
        if (y >= y_array[i] && y < y_array[i+1]) {
            alpha = (y - y_array[i]) / (y_array[i+1] - y_array[i]);
            x = x_array[i] + alpha * (x_array[i+1] - x_array[i]);
        }
    }
    if (y < y_array[0]) {
        x = x_array[0];
    }else if (y >= y_array.back()){
        x = x_array.back();
    }
    return x;
}

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
xorpd %xmm1, %xmm1
cmpq $0x1, %rdx
je 0x6584
movl $0x1, %esi
movsd -0x8(%rcx,%rsi,8), %xmm2
ucomisd %xmm2, %xmm0
jb 0x657c
movsd (%rcx,%rsi,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x657c
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
subsd %xmm2, %xmm3
divsd %xmm3, %xmm4
movq (%rdi), %r8
movsd -0x8(%r8,%rsi,8), %xmm2
movsd (%r8,%rsi,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
incq %rsi
cmpq %rsi, %rdx
jne 0x6539
movsd (%rcx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x6593
movq (%rdi), %rax
jmp 0x65a2
ucomisd -0x8(%rax), %xmm0
jb 0x65a6
movq 0x8(%rdi), %rax
addq $-0x8, %rax
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/DenseStorage.h
// Function: Eigen::DenseStorage<double, -1, -1, -1, 0>::resize(long, long, long)
void resize(DenseIndex size, DenseIndex nbRows, DenseIndex nbCols)
    {
      if(size != m_rows*m_cols)
      {
        internal::conditional_aligned_delete_auto<T,(_Options&DontAlign)==0>(m_data, m_rows*m_cols);
        if (size)
          m_data = internal::conditional_aligned_new_auto<T,(_Options&DontAlign)==0>(size);
        else
          m_data = 0;
        EIGEN_INTERNAL_DENSE_STORAGE_CTOR_PLUGIN
      }
      m_rows = nbRows;
      m_cols = nbCols;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rax
imulq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x6cc8
movq %rsi, %r12
movq (%r15), %rdi
callq 0x5460
testq %r12, %r12
je 0x6cc3
movq %r12, %rax
shrq $0x3d, %rax
jne 0x6c95
shlq $0x3, %r12
movq %r12, %rdi
callq 0x54d0
testq %rax, %rax
jne 0x6cc5
movl $0x8, %edi
callq 0x51e0
movq 0x2c2f2(%rip), %rcx     # 0x32f98
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x2c304(%rip), %rsi     # 0x32fb8
movq 0x2c2c5(%rip), %rdx     # 0x32f80
movq %rax, %rdi
callq 0x5620
xorl %eax, %eax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::quatNAVI2BODY(double)
Quaterniond RocketStage::quatNAVI2BODY(double t){
    Quaterniond quatNAVI2BODY_, quat_drift_NAVI2BODY_;

    double gyro_bias_abs = this->gyro_bias.norm();
    if (gyro_bias_abs != 0.0) {
        Vector3d gyro_bias_direction = this->gyro_bias / gyro_bias_abs;
        quat_drift_NAVI2BODY_ = Quaterniond(AngleAxisd(gyro_bias_abs * t, gyro_bias_direction));
    } else {
        quat_drift_NAVI2BODY_ = Quaterniond::Identity();
    }

    quatNAVI2BODY_ = this->quat_offset_NAVI2BODY * quat_drift_NAVI2BODY_;
    return quatNAVI2BODY_;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x630(%rsi), %xmm1
movsd 0x638(%rsi), %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm2
movsd 0x640(%rsi), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x14dab
sqrtsd %xmm0, %xmm0
jmp 0x14db4
callq 0x52e0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x14dc0
jnp 0x14e58
movsd 0x630(%r14), %xmm2
movsd 0x638(%r14), %xmm1
divsd %xmm0, %xmm2
movapd %xmm2, 0x30(%rsp)
divsd %xmm0, %xmm1
movapd %xmm1, 0x40(%rsp)
movsd 0x640(%r14), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
mulsd 0x12ee5(%rip), %xmm1    # 0x27cf0
movsd %xmm1, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x5690
movapd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x50f0
movapd 0x10(%rsp), %xmm8
movapd 0x30(%rsp), %xmm7
mulsd %xmm0, %xmm7
movapd 0x40(%rsp), %xmm1
mulsd %xmm0, %xmm1
unpcklpd %xmm1, %xmm7            # xmm7 = xmm7[0],xmm1[0]
mulsd %xmm0, %xmm8
unpcklpd 0x20(%rsp), %xmm8       # xmm8 = xmm8[0],mem[0]
jmp 0x14e6a
xorpd %xmm7, %xmm7
xorpd %xmm8, %xmm8
movhpd 0x121a6(%rip), %xmm8    # xmm8 = xmm8[0],mem[0]
movapd 0x610(%r14), %xmm0
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movupd 0x618(%r14), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
movapd 0x620(%r14), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movupd 0x628(%r14), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd %xmm7, %xmm4
mulpd %xmm1, %xmm4
movapd %xmm8, %xmm5
mulpd %xmm3, %xmm5
addpd %xmm4, %xmm5
movapd %xmm7, %xmm4
mulpd %xmm2, %xmm4
movapd %xmm8, %xmm6
mulpd %xmm0, %xmm6
subpd %xmm6, %xmm4
pshufd $0x4e, %xmm4, %xmm4     # xmm4 = xmm4[2,3,0,1]
movq 0x12deb(%rip), %xmm6    # 0x27cc0
pxor %xmm6, %xmm4
addpd %xmm5, %xmm4
mulpd %xmm8, %xmm1
mulpd %xmm7, %xmm3
subpd %xmm3, %xmm1
mulpd %xmm8, %xmm2
mulpd %xmm7, %xmm0
addpd %xmm2, %xmm0
pshufd $0x4e, %xmm0, %xmm0     # xmm0 = xmm0[2,3,0,1]
pxor %xmm6, %xmm0
subpd %xmm0, %xmm1
movapd %xmm4, (%rbx)
movapd %xmm1, 0x10(%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::progress(double)
void RocketStage::progress(double time_now){
    double time_total = calc_end_time;
    cout << fixed << setprecision(0);
    cout << time_now << "sec / " << time_total << "sec\t@Stage " << num_stage << "\r" << flush;
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x260(%rdi), %xmm1
movsd %xmm1, (%rsp)
movq 0x1e07d(%rip), %rdi     # 0x32fb0
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx       # imm = 0xFFFFFEFB
andl 0x18(%rdi,%rcx), %edx
orl $0x4, %edx
movl %edx, 0x18(%rdi,%rcx)
movq -0x18(%rax), %rax
movq $0x0, 0x8(%rdi,%rax)
callq 0x5570
movq %rax, %r14
leaq 0x13a0d(%rip), %rsi     # 0x28973
movl $0x6, %edx
movq %rax, %rdi
callq 0x5430
movq %r14, %rdi
movsd (%rsp), %xmm0
callq 0x5570
movq %rax, %r14
leaq 0x139f0(%rip), %rsi     # 0x2897a
movl $0xb, %edx
movq %rax, %rdi
callq 0x5430
movl 0x250(%rbx), %esi
movq %r14, %rdi
callq 0x5630
movq %rax, %rbx
leaq 0x13881(%rip), %rsi     # 0x28830
movl $0x1, %edx
movq %rax, %rdi
callq 0x5430
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5270
nop
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: operator>>(std::istream&, picojson::value&)
inline std::istream& operator>>(std::istream& is, picojson::value& x)
{
  picojson::set_last_error(std::string());
  std::string err = picojson::parse(x, is);
  if (! err.empty()) {
    picojson::set_last_error(err);
    is.setstate(std::ios::failbit);
  }
  return is;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x1c6d8(%rip), %rdi     # 0x333f0
leaq 0x8(%rsp), %rsi
callq 0x5220
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16d39
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53b0
leaq 0x8(%rsp), %rcx
movq %r15, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movb $0x0, 0x10(%rcx)
movq (%rbx), %rdx
movq -0x18(%rdx), %rdx
movq 0xe8(%rbx,%rdx), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, (%rsi)
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl %edi, 0x8(%rsi)
leaq 0x30(%rsp), %rdx
movq %rax, (%rdx)
movl %edi, 0x8(%rdx)
leaq 0x28(%rsp), %rdi
movq %r14, (%rdi)
callq 0x183dc
cmpq $0x0, 0x10(%rsp)
je 0x16db2
leaq 0x1c65f(%rip), %rdi     # 0x333f0
leaq 0x8(%rsp), %rsi
callq 0x5220
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x4, %esi
callq 0x55f0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16dc9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x16dda
jmp 0x16dda
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16df4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::~value()
inline value::~value() {
    switch (type_) {
#define DEINIT(p) case p##type: delete u_.p; break
      DEINIT(string_);
      DEINIT(array_);
      DEINIT(object_);
#undef DEINIT
    default: break;
    }
  }

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl $0x5, %eax
je 0x16ef9
cmpl $0x4, %eax
je 0x16ee1
cmpl $0x3, %eax
jne 0x16f18
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x16f18
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x16eda
movq (%rax), %rsi
incq %rsi
callq 0x53b0
movl $0x20, %esi
jmp 0x16f0f
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x16f18
movq %rbx, %rdi
callq 0x763e
movl $0x18, %esi
jmp 0x16f0f
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x16f18
movq %rbx, %rdi
callq 0x7546
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x53b0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/rocket.hpp
// Function: CsvObserver::CsvObserver(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
CsvObserver(const std::string& FileName, bool isAddition = false){
        if (isAddition == false){ // 追加書き込みモードかどうか
            fout.open(FileName, std::ios_base::out);
            fout << header << std::endl;
        } else {
            fout.open(FileName, std::ios_base::out | std::ios_base::app); // 追加書き込みモード
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x1a170
leaq 0x1ac19(%rip), %rax     # 0x32630
movq %rax, (%rbx)
leaq 0xec0(%rbx), %r14
movq %r14, %rdi
callq 0x5600
leaq 0x10c0(%rbx), %r15
leaq 0x10d0(%rbx), %r13
movq %r13, 0x10c0(%rbx)
leaq 0x110da(%rip), %rsi     # 0x28b1f
leaq 0x114c4(%rip), %rdx     # 0x28f10
movq %r15, %rdi
callq 0x7786
testb %bpl, %bpl
je 0x17a6b
movq %r14, %rdi
movq %r12, %rsi
movl $0x11, %edx
callq 0x51c0
jmp 0x17abb
movq %r14, %rdi
movq %r12, %rsi
movl $0x10, %edx
callq 0x51c0
movq 0x10c0(%rbx), %rsi
movq 0x10c8(%rbx), %rdx
movq %r14, %rdi
callq 0x5430
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5370
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x5270
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x17aeb
movq %rax, %r12
jmp 0x17af3
movq %rax, %r12
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x17aeb
movq (%r13), %rsi
incq %rsi
callq 0x53b0
movq %r14, %rdi
callq 0x5510
movq %rbx, %rdi
callq 0x7358
movq %r12, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: std::istreambuf_iterator<char, std::char_traits<char>> picojson::_parse<picojson::default_parse_context, std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::default_parse_context&, std::istreambuf_iterator<char, std::char_traits<char>> const&, std::istreambuf_iterator<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err) {
    input<Iter> in(first, last);
    if (! _parse(ctx, in) && err != NULL) {
      char buf[64];
      SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
      *err = buf;
      while (1) {
	int ch = in.getc();
	if (ch == -1 || ch == '\n') {
	  break;
	} else if (ch >= ' ') {
	  err->push_back(ch);
	}
      }
    }
    return in.cur();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movups (%rsi), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movups (%rdx), %xmm0
movaps %xmm0, 0x10(%rsi)
movb $0x0, 0x20(%rsi)
movl $0x1, 0x24(%rsi)
callq 0x184bd
testq %rbx, %rbx
je 0x18478
testb %al, %al
jne 0x18478
movq %rsp, %r14
movl 0x24(%r14), %ecx
leaq 0x10567(%rip), %rdx     # 0x28988
leaq 0x30(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x5560
movq 0x8(%rbx), %r12
movq %r15, %rdi
callq 0x51a0
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x5540
movq %r14, %rdi
callq 0x18864
cmpl $-0x1, %eax
je 0x18478
cmpl $0xa, %eax
je 0x18478
cmpl $0x20, %eax
jl 0x18454
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5330
jmp 0x18454
cmpb $0x1, 0x20(%rsp)
jne 0x184a1
movb $0x0, 0x20(%rsp)
movq (%rsp), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x184b5
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%rsp)  # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl 0x8(%rsp), %edx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x18499
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::getc()
int getc() {
      if (consumed_) {
        if (*cur_ == '\n') {
          ++line_;
        }
        ++cur_;
      }
      if (cur_ == end_) {
        consumed_ = false;
        return -1;
      }
      consumed_ = true;
      return *cur_ & 0xff;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x1889b
movq %rbx, %rdi
callq 0x1994e
cmpb $0xa, %al
jne 0x18880
incl 0x24(%rbx)
movq (%rbx), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x188e0
incq %rax
movq %rax, 0x10(%rdi)
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
leaq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x1994e
cmpl $-0x1, %eax
sete %bpl
movq %r14, %rdi
callq 0x1994e
cmpl $-0x1, %eax
setne %al
cmpb %al, %bpl
je 0x188cc
movb $0x0, 0x20(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x188db
movb $0x1, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1994e
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x18894
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::_parse_object<picojson::default_parse_context, std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::default_parse_context&, picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&)
inline bool _parse_object(Context& ctx, input<Iter>& in) {
    if (! ctx.parse_object_start()) {
      return false;
    }
    if (in.expect('}')) {
      return true;
    }
    do {
      std::string key;
      if (! in.expect('"')
	  || ! _parse_string(key, in)
	  || ! in.expect(':')) {
	return false;
      }
      if (! ctx.parse_object_item(in, key)) {
	return false;
      }
    } while (in.expect(','));
    return in.expect('}');
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x19420
testb %al, %al
je 0x18c16
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x19060
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x18c18
leaq 0x10(%rsp), %r12
movq %rsp, %r15
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x22, %esi
callq 0x19060
testb %al, %al
je 0x18bd5
movq %r15, %rdi
movq %rbx, %rsi
callq 0x18d41
testb %al, %al
je 0x18bd5
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x19060
testb %al, %al
je 0x18bd5
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x194ea
movl %eax, %ebp
jmp 0x18bd7
xorl %ebp, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x18bed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
testb %bpl, %bpl
je 0x18c16
movq %rbx, %rdi
movl $0x2c, %esi
callq 0x19060
testb %al, %al
jne 0x18b80
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x19060
jmp 0x18c18
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x18c3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::_parse_string<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::istreambuf_iterator<char, std::char_traits<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&)
inline bool _parse_string(String& out, input<Iter>& in) {
    while (1) {
      int ch = in.getc();
      if (ch < ' ') {
	in.ungetc();
	return false;
      } else if (ch == '"') {
	return true;
      } else if (ch == '\\') {
	if ((ch = in.getc()) == -1) {
	  return false;
	}
	switch (ch) {
#define MAP(sym, val) case sym: out.push_back(val); break
	  MAP('"', '\"');
	  MAP('\\', '\\');
	  MAP('/', '/');
	  MAP('b', '\b');
	  MAP('f', '\f');
	  MAP('n', '\n');
	  MAP('r', '\r');
	  MAP('t', '\t');
#undef MAP
	case 'u':
	  if (! _parse_codepoint(out, in)) {
	    return false;
	  }
	  break;
	default:
	  return false;
	}
      } else {
	out.push_back(ch);
      }
    }
    return false;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf2ab(%rip), %r15      # 0x28000
movl %eax, %ebp
movq %rbx, %rdi
callq 0x18864
cmpl $0x1f, %eax
jg 0x18d6c
movb $0x0, 0x20(%rbx)
xorl %eax, %eax
jmp 0x18da1
cmpl $0x22, %eax
je 0x18d9f
cmpl $0x5c, %eax
jne 0x18df2
movq %rbx, %rdi
callq 0x18864
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x61, %ecx
jg 0x18da5
cmpl $0x22, %ecx
je 0x18dbc
cmpl $0x2f, %ecx
je 0x18dc0
movl $0x0, %edx
cmpl $0x5c, %ecx
jne 0x18e01
movb $0x5c, %al
jmp 0x18df2
movb $0x1, %al
xorl %edx, %edx
jmp 0x18e01
leal -0x6e(%rcx), %edx
cmpl $0x7, %edx
ja 0x18dc4
movslq (%r15,%rdx,4), %rcx
addq %r15, %rcx
xorl %edx, %edx
jmpq *%rcx
movb $0xa, %al
jmp 0x18df2
movb $0x22, %al
jmp 0x18df2
movb $0x2f, %al
jmp 0x18df2
cmpl $0x62, %ecx
je 0x18df0
movl $0x0, %edx
cmpl $0x66, %ecx
jne 0x18e01
movb $0xc, %al
jmp 0x18df2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18e16
testb %al, %al
je 0x18d68
jmp 0x18dfd
movb $0xd, %al
jmp 0x18df2
movb $0x9, %al
jmp 0x18df2
movb $0x8, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x5330
movb $0x1, %dl
movl %ebp, %eax
testb %dl, %dl
jne 0x18d55
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::expect(int)
bool expect(int expect) {
      skip_ws();
      if (getc() != expect) {
	ungetc();
	return false;
      }
      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movabsq $0x100002600, %r15      # imm = 0x100002600
movq %r14, %rdi
callq 0x18864
cmpl $0x20, %eax
ja 0x19089
movl %eax, %eax
btq %rax, %r15
jb 0x19074
movb $0x0, 0x20(%r14)
movq %r14, %rdi
callq 0x18864
cmpl %ebx, %eax
je 0x1909f
movb $0x0, 0x20(%r14)
cmpl %ebx, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::default_parse_context::parse_array_item<std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&, unsigned long)
bool parse_array_item(input<Iter>& in, size_t) {
      array& a = out_->get<array>();
      a.push_back(value());
      default_parse_context ctx(&a.back());
      return _parse(ctx, in);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rax
cmpl $0x4, (%rax)
jne 0x19169
movq %rsi, %rbx
movq 0x8(%rax), %r14
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r14, %rdi
callq 0x191bc
movl (%rsp), %eax
cmpl $0x5, %eax
je 0x1912a
cmpl $0x4, %eax
je 0x19111
cmpl $0x3, %eax
jne 0x19149
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x19149
movq (%r15), %rdi
leaq 0x10(%r15), %rax
cmpq %rax, %rdi
je 0x1910a
movq (%rax), %rsi
incq %rsi
callq 0x53b0
movl $0x20, %esi
jmp 0x19141
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x19149
movq %r15, %rdi
callq 0x763e
movl $0x18, %esi
jmp 0x19141
movq 0x8(%rsp), %r15
testq %r15, %r15
je 0x19149
movq %r15, %rdi
callq 0x7546
movl $0x30, %esi
movq %r15, %rdi
callq 0x53b0
movq 0x8(%r14), %rax
addq $-0x10, %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0x184bd
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x51e0
movq %rax, %rbx
leaq 0xf91d(%rip), %rsi      # 0x28a9a
movq %rax, %rdi
callq 0x5180
movq 0x19e64(%rip), %rsi     # 0x32ff0
movq 0x19e0d(%rip), %rdx     # 0x32fa0
movq %rbx, %rdi
callq 0x5620
movq %rax, %r14
movq %rbx, %rdi
callq 0x52a0
jmp 0x191b3
movq %rax, %r14
movq %rsp, %rdi
callq 0x16ea8
movq %r14, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::value(picojson::value const&)
inline value::value(const value& x) : type_(x.type_) {
    switch (type_) {
#define INIT(p, v) case p##type: u_.p = v; break
      INIT(string_, new std::string(*x.u_.string_));
      INIT(array_, new array(*x.u_.array_));
      INIT(object_, new object(*x.u_.object_));
#undef INIT
    default:
      u_ = x.u_;
      break;
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
cmpl $0x5, %eax
je 0x19cbb
cmpl $0x4, %eax
je 0x19ca0
cmpl $0x3, %eax
jne 0x19cda
movl $0x20, %edi
callq 0x53a0
movq %rax, %r15
movq 0x8(%r14), %rax
leaq 0x10(%r15), %rcx
movq %rcx, (%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x76f6
jmp 0x19cd4
movl $0x18, %edi
callq 0x53a0
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x19d14
jmp 0x19cd4
movl $0x30, %edi
callq 0x53a0
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x199fc
movq %r15, 0x8(%rbx)
jmp 0x19ce2
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
jmp 0x19d04
movq %rax, %rbx
movl $0x30, %esi
jmp 0x19d04
movq %rax, %rbx
movl $0x18, %esi
movq %r15, %rdi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/integrate/max_step_checker.hpp
// Function: boost::numeric::odeint::failed_step_checker::operator()()
void operator()(void)
    {
        if( m_steps++ >= m_max_steps )
        {
            char error_msg[200];
            sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps);
            BOOST_THROW_EXCEPTION( step_adjustment_error(error_msg) );
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movl (%rdi), %edx
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl %edx, %eax
jge 0x1ba50
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
leaq 0xd9fb(%rip), %rsi      # 0x29452
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50e0
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rbx, %rdi
callq 0x51a0
leaq (%rsp,%rax), %rdx
addq $0x50, %rdx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7786
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x54a0
leaq 0x16d05(%rip), %rax     # 0x327a8
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0xd9e7(%rip), %rax      # 0x29499
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xda0e(%rip), %rax      # 0x294cf
movq %rax, 0x8(%rsi)
movq $0x69, 0x10(%rsi)
callq 0x1c2ae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5400
jmp 0x1bae4
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x1bafb
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
// Function: double boost::numeric::odeint::default_error_checker<double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>::error<std::array<double, 14ul>, std::array<double, 14ul>, std::array<double, 14ul>, double>(boost::numeric::odeint::array_algebra&, std::array<double, 14ul> const&, std::array<double, 14ul> const&, std::array<double, 14ul>&, double) const
value_type error( algebra_type &algebra , const State &x_old , const Deriv &dxdt_old , Err &x_err , Time dt ) const
    {
        using std::abs;
        // this overwrites x_err !
        algebra.for_each3( x_err , x_old , dxdt_old ,
                typename operations_type::template rel_error< value_type >( m_eps_abs , m_eps_rel , m_a_x , m_a_dxdt * abs(get_unit_value( dt )) ) );

        // value_type res = algebra.reduce( x_err ,
        //        typename operations_type::template maximum< value_type >() , static_cast< value_type >( 0 ) );
        return algebra.norm_inf( x_err );
    }

// Assembly:
movsd (%rdi), %xmm1
movsd 0x8(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
andpd 0xb478(%rip), %xmm0     # 0x27030
mulsd 0x18(%rdi), %xmm0
xorl %eax, %eax
movapd 0xb469(%rip), %xmm4     # 0x27030
movsd (%r8,%rax,8), %xmm5
andpd %xmm4, %xmm5
movsd (%rdx,%rax,8), %xmm6
andpd %xmm4, %xmm6
movsd (%rcx,%rax,8), %xmm7
andpd %xmm4, %xmm7
mulsd %xmm0, %xmm7
mulsd %xmm3, %xmm6
addsd %xmm7, %xmm6
mulsd %xmm2, %xmm6
addsd %xmm1, %xmm6
divsd %xmm6, %xmm5
movsd %xmm5, (%r8,%rax,8)
incq %rax
cmpq $0xe, %rax
jne 0x1bbc7
xorpd %xmm0, %xmm0
xorl %eax, %eax
movapd 0xb418(%rip), %xmm1     # 0x27030
movapd %xmm0, %xmm2
movsd (%r8,%rax,8), %xmm0
andpd %xmm1, %xmm0
maxsd %xmm2, %xmm0
incq %rax
cmpq $0xe, %rax
jne 0x1bc18
retq
// File: /workspace/github_cpp_makefile_star2_O1/istellartech[P]OpenTsiolkovsky/src/fileio.cpp
// Function: interp_matrix(double, Eigen::Matrix<double, -1, -1, 0, -1, -1>, int)
double interp_matrix(double x, MatrixXd matrix, int col_num){
    // 線形補間をする、外挿は無し。点の外は最外点そのまま
    // (x, y)の行が沢山並んでいるのを想定
    // @params x 取得したいデータのx成分
    // @params matrix 2x? データ配列(x,y)
    // @params col_num 取得したいデータの列数 default:1
    // @return y(double) 入力xのデータ
    double y = 0.0;
    double alpha = 0.0;
    for (int i = 0; i < matrix.rows()-1; i++) {
        if (x >= matrix(i,0) && x < matrix(i+1,0)) {
            alpha = (x - matrix(i,0)) / (matrix(i+1,0) - matrix(i,0));
            y = matrix(i,col_num) + alpha * (matrix(i+1,col_num) - matrix(i,col_num));
        }
    }
    if (x < matrix(0,0)) {
        y = matrix(0,col_num);
    }else if (x >= matrix(matrix.rows()-1,0)){
        y = matrix(matrix.rows()-1,col_num);
    }
    return y;
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
leaq -0x1(%rax), %rcx
xorpd %xmm1, %xmm1
cmpq $0x2, %rax
jl 0x1c81f
movslq %esi, %rdx
movq %rax, %r8
imulq %rdx, %r8
shlq $0x3, %r8
xorl %r9d, %r9d
cmpq %r9, %rax
je 0x1c87a
movq 0x10(%rdi), %r11
testq %r11, %r11
jle 0x1c87a
movq (%rdi), %r10
movsd (%r10,%r9,8), %xmm2
ucomisd %xmm2, %xmm0
jb 0x1c817
movsd 0x8(%r10,%r9,8), %xmm3
ucomisd %xmm0, %xmm3
jbe 0x1c817
testl %esi, %esi
js 0x1c87a
cmpq %rdx, %r11
jle 0x1c87a
movapd %xmm0, %xmm4
subsd %xmm2, %xmm4
subsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addq %r8, %r10
movsd (%r10,%r9,8), %xmm2
movsd 0x8(%r10,%r9,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm4, %xmm1
addsd %xmm2, %xmm1
incq %r9
cmpq %r9, %rcx
jne 0x1c7a8
testq %rax, %rax
jle 0x1c87a
movq 0x10(%rdi), %r8
testq %r8, %r8
jle 0x1c87a
movq (%rdi), %rdx
movsd (%rdx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x1c850
testl %esi, %esi
js 0x1c87a
movslq %esi, %rcx
cmpq %rcx, %r8
jle 0x1c87a
imulq %rcx, %rax
leaq (%rdx,%rax,8), %rax
jmp 0x1c870
ucomisd -0x8(%rdx,%rax,8), %xmm0
jb 0x1c874
testl %esi, %esi
js 0x1c87a
movslq %esi, %rsi
cmpq %rsi, %r8
jle 0x1c87a
imulq %rsi, %rax
leaq (%rdx,%rax,8), %rax
leaq (%rax,%rcx,8), %rax
movsd (%rax), %xmm1
movapd %xmm1, %xmm0
popq %rax
retq
leaq 0xae4c(%rip), %rdi      # 0x276cd
leaq 0xae7a(%rip), %rsi      # 0x27702
leaq 0xae9f(%rip), %rcx      # 0x2772e
movl $0x151, %edx            # imm = 0x151
callq 0x5250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f6ba
movq %rax, %r12
testq %rax, %rax
je 0x1db42
leaq 0x1d0(%rbx), %rsi
leaq 0x220(%rbx), %rdx
movq %r12, %rdi
callq 0x2008c
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x20224
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 0x1db99
movq %r14, %rdi
callq 0x5190
movq %rax, %r14
leaq 0xc8(%rbx), %rsi
movl $0xff, %edx
movq %rax, %rdi
callq 0x5200
movb $0x0, 0xff(%r14)
callq 0x54f0
jmp 0x1dbb4
movq %rdx, %r15
movq %rax, %r14
callq 0x55a0
cmpl $0x1, %r15d
jne 0x1dbbc
movq %r14, %rdi
callq 0x5190
movl 0x1c8(%rbx), %ecx
movl %ecx, (%rax)
callq 0x54f0
movq %rax, %r14
callq 0x55a0
movq %r14, %rdi
callq 0x5650
movq %rax, %rdi
callq 0x7309
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22018
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 0x21f2e
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ea61
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x53b0
xorps %xmm0, %xmm0
movups %xmm0, 0x230(%rbx)
movups %xmm0, 0x220(%rbx)
movups %xmm0, 0x210(%rbx)
movups %xmm0, 0x200(%rbx)
movups %xmm0, 0x1f0(%rbx)
movups %xmm0, 0x1e0(%rbx)
movups %xmm0, 0x1d0(%rbx)
movq $0x0, 0x240(%rbx)
leaq 0x428(%rbx), %rdi
movl $0xf, %esi
callq 0x1ee78
movq 0x428(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, (%rax,%rcx,4)
incq %rcx
cmpq $0xf, %rcx
jne 0x1eaba
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1eaf3
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x53b0
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ecf4
leaq 0x30(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x1ed5e
movb $0x1, %al
movq %rsp, %rdi
movb %al, 0x8(%rdi)
movb %al, 0x10(%rbx)
callq 0x1ed48
leaq 0x88(%rbx), %rdi
callq 0x51f0
leaq 0x8(%rbx), %rdi
callq 0x5610
leaq 0x88(%rbx), %rdi
callq 0x5680
leaq 0x58(%rbx), %rdi
callq 0x5680
cmpq $0x0, 0x18(%rbx)
je 0x1ed19
leaq 0x18(%rbx), %rdi
callq 0x5320
cmpq $0x0, 0x8(%rbx)
jne 0x1ed3b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ed2e
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
callq 0x5110
movq %rax, %rdi
callq 0x7309
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x1c8(%rdi)
movl $0x3000000, %edi        # imm = 0x3000000
callq 0x5030
movq %rax, 0xb8(%rbx)
movl %ebp, 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 0x1ef14
movq 0xb8(%rbx), %rcx
cmpb $-0x11, (%rcx)
jne 0x1ef14
cmpb $-0x45, 0x1(%rcx)
jne 0x1ef14
cmpb $-0x41, 0x2(%rcx)
jne 0x1ef14
movl $0x3, 0xc0(%rbx)
cmpl $0x2000000, %eax        # imm = 0x2000000
jne 0x1ef67
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, (%r14)
movq %rbx, %rdi
callq 0x1f108
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ef45
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rsp)
movl $0x2000000, %esi        # imm = 0x2000000
addq 0xb8(%rbx), %rsi
movq %rbx, %rdi
movl $0x1000000, %edx        # imm = 0x1000000
callq 0x1f1a8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1ef83
movq (%rdi), %rax
callq *0x10(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x1ef91
movq %rax, %r14
movq %r14, %rdi
callq 0x5190
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x1efaa
callq 0x54b0
callq 0x54f0
movq %rax, %rbx
callq 0x55a0
movq %rbx, %rdi
callq 0x5650
movq %rax, %rdi
callq 0x7309
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa888(%rip), %rsi      # 0x2986e
movq %r15, %rdi
callq 0x5450
testq %rax, %rax
je 0x1f03a
movq %rax, %r14
movl $0x10, %edi
callq 0x53a0
movq %rax, %r15
leaq 0x13906(%rip), %rax     # 0x32910
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x5040
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 0x5070
movl (%rax), %ebp
movl $0x108, %ebx            # imm = 0x108
leaq 0x8(%rsp), %r12
leaq (%r12,%rbx), %r14
movl $0x104, %edx            # imm = 0x104
movq %r14, %rdi
xorl %esi, %esi
callq 0x5230
leaq 0x1384b(%rip), %r13     # 0x328b0
movq %r13, (%r12)
movl %ebp, 0x208(%r12)
movl $0xff, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5200
movb $0x0, 0x207(%r12)
movl $0x210, %edi            # imm = 0x210
callq 0x51e0
movq %rax, %r15
leaq 0x13842(%rip), %rax     # 0x328e0
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 0x13775(%rip), %rsi     # 0x32858
movq 0x13ee6(%rip), %rdx     # 0x32fd0
movq %r15, %rdi
callq 0x5620
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56d8
movq %rbx, %rdi
callq 0x5650
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0x1ed5e
movb $0x1, 0x8(%r12)
movq %r14, 0x20(%r15)
movl %ebx, 0x28(%r15)
movl $0xffffffff, 0x2c(%r15) # imm = 0xFFFFFFFF
addq $0x88, %r15
movq %r15, %rdi
callq 0x51f0
movq %r12, %rdi
callq 0x1ed48
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f446
callq 0x5160
leaq 0xa447(%rip), %rdx      # 0x29871
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 0xa449(%rip), %rdx      # 0x29896
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5560