LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/rocket.cpp
// Function: RocketStage::free_flight_ballistic(std::array<double, 14ul> const&, double)
void RocketStage::free_flight_ballistic(const RocketStage::state& x, double t){
    flight_mode = "free_ballistic";
    //    aerodynamics term
    vel_AIR_NEDframe_ = vel_ECEF_NEDframe_ - vel_wind_NEDframe_;
    vel_AIR_NEDframe_abs = vel_AIR_NEDframe_.norm();
    mach_number = vel_AIR_NEDframe_abs / air.airspeed;
    dynamic_pressure = 0.5 * air.density * vel_AIR_NEDframe_abs * vel_AIR_NEDframe_abs;
    force_axial = dynamic_pressure / ballistic_coef;
    force_air_vector_NEDframe = force_axial * (-1) * (vel_AIR_NEDframe_ / vel_AIR_NEDframe_abs);
    force_normal_pitch = force_normal_yaw = 0.0; // for csv output
    force_air_vector_BODYframe << -force_axial, 0.0, 0.0; // for csv output
    //    dv/dt
    accECI_ = dcmNED2ECI_ * force_air_vector_NEDframe + gravityECI_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
addq $0x230, %rdi            # imm = 0x230
leaq 0x127ce(%rip), %rsi     # 0x20af8
callq 0x56a0
leaq 0xbb8(%rbx), %rax
leaq 0xbd0(%rbx), %rcx
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rcx, 0x8(%r14)
leaq 0xc00(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x15cd4
movq %r15, %rdi
callq 0x10c94
movsd %xmm0, 0x7d0(%rbx)
movapd %xmm0, %xmm1
divsd 0x900(%rbx), %xmm1
movsd %xmm1, 0x958(%rbx)
movsd 0x910(%rbx), %xmm1
mulsd 0x11aa9(%rip), %xmm1    # 0x1fe38
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x7d8(%rbx)
divsd 0x288(%rbx), %xmm1
movsd %xmm1, 0x7e0(%rbx)
xorpd 0x10c59(%rip), %xmm1    # 0x1f010
movq %r15, 0x8(%r14)
movsd %xmm0, 0x10(%r14)
movlpd %xmm1, 0x18(%r14)
leaq 0xe10(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x15d44
xorpd %xmm0, %xmm0
movupd %xmm0, 0x7e8(%rbx)
leaq 0xdf8(%rbx), %rax
movsd 0x7e0(%rbx), %xmm0
xorps 0x10c10(%rip), %xmm0    # 0x1f010
movq %rax, (%r15)
andq $0x0, 0x8(%r15)
pushq $0x1
popq %rax
movq %rax, 0x10(%r15)
movq %rax, 0x18(%r15)
movlps %xmm0, 0xdf8(%rbx)
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xfd60
leaq 0x30(%rsp), %rsi
andq $0x0, (%rsi)
movq %rax, %rdi
callq 0xfd60
leaq 0x8(%rsp), %rdi
callq 0xfe08
leaq 0xb70(%rbx), %rax
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
leaq 0xe58(%rbx), %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1543a
movq %r15, 0x18(%r14)
addq $0x9f0, %rbx            # imm = 0x9F0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15dc0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xe491
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xfe08
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x630(%rsi), %r15
movq %r15, %rdi
callq 0x10c94
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xe810
jnp 0xe876
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movsd %xmm0, 0x8(%rsi)
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x155d4
movsd (%rsp), %xmm0
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x129c6
movsd (%rsp), %xmm0
movsd %xmm0, 0x18(%r12)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1563e
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
jmp 0xe89b
leaq 0x30(%rsp), %rsi
andq $0x0, 0x10(%rsi)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x18(%rsi)
leaq 0x10(%rsp), %rdi
callq 0x12a3a
addq $0x610, %r14            # imm = 0x610
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x15840
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12a3a
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x260(%rdi), %xmm1
movsd %xmm1, 0x8(%rsp)
movq 0x206b9(%rip), %rdi     # 0x2efb0
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
andq $0x0, 0x8(%rdi,%rax)
callq 0x5570
leaq 0x121e3(%rip), %rsi     # 0x20b07
movq %rax, %rdi
callq 0x5370
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x5570
leaq 0x121cd(%rip), %rsi     # 0x20b0e
movq %rax, %rdi
callq 0x5370
movl 0x250(%rbx), %esi
movq %rax, %rdi
callq 0x5620
leaq 0x12066(%rip), %rsi     # 0x209c4
movq %rax, %rdi
callq 0x5370
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x5270
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0x10d9f
movq %rsp, %rdi
callq 0x56e8
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10dae
cmpq $0x0, 0x8(%r15)
je 0xf98c
movq %rsp, %rdi
callq 0x10d9f
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
pushq $0x4
popq %rsi
callq 0x5240
movq %rsp, %rdi
callq 0x56e8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf9a3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x56e8
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, picojson::value, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, picojson::value>>>& picojson::value::get<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, picojson::value, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, picojson::value>>>>()
inline bool value::is<double>() const {
    return type_ == number_type
#ifdef PICOJSON_USE_INT64
      || type_ == int64_type
#endif
      ;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x5, (%rdi)
jne 0xf9cb
movq 0x8(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51c0
movq %rax, %rbx
leaq 0x11185(%rip), %rsi     # 0x20b62
movq %rax, %rdi
callq 0x5160
movq 0x1f604(%rip), %rsi     # 0x2eff0
movq 0x1f5ad(%rip), %rdx     # 0x2efa0
movq %rbx, %rdi
callq 0x5610
movq %rax, %r14
movq %rbx, %rdi
callq 0x52a0
movq %r14, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
callq 0x12676
leaq 0x1e198(%rip), %rax     # 0x2e610
movq %rax, (%rbx)
leaq 0xec0(%rbx), %r14
movq %r14, %rdi
callq 0x55f0
leaq 0x10c0(%rbx), %r15
leaq 0x10820(%rip), %rsi     # 0x20cb8
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x6c7e
testb %bpl, %bpl
je 0x104ba
pushq $0x11
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x51a0
jmp 0x104db
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x51a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5340
movq %rax, %rdi
callq 0x51b0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x104fd
movq %rax, %r12
jmp 0x10505
movq %rax, %r12
movq %r15, %rdi
callq 0x56e8
movq %r14, %rdi
callq 0x5500
movq %rbx, %rdi
callq 0x6e12
movq %r12, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Geometry/Quaternion.h
// Function: Eigen::QuaternionBase<Eigen::Quaternion<double, 0>>::toRotationMatrix() const
inline typename QuaternionBase<Derived>::Matrix3
QuaternionBase<Derived>::toRotationMatrix(void) const
{
  // NOTE if inlined, then gcc 4.2 and 4.4 get rid of the temporary (not gcc 4.3 !!)
  // if not inlined then the cost of the return by value is huge ~ +35%,
  // however, not inlining this function is an order of magnitude slower, so
  // it has to be inlined, and so the return by value is not an issue
  Matrix3 res;

  const Scalar tx  = Scalar(2)*this->x();
  const Scalar ty  = Scalar(2)*this->y();
  const Scalar tz  = Scalar(2)*this->z();
  const Scalar twx = tx*this->w();
  const Scalar twy = ty*this->w();
  const Scalar twz = tz*this->w();
  const Scalar txx = tx*this->x();
  const Scalar txy = ty*this->x();
  const Scalar txz = tz*this->x();
  const Scalar tyy = ty*this->y();
  const Scalar tyz = tz*this->y();
  const Scalar tzz = tz*this->z();

  res.coeffRef(0,0) = Scalar(1)-(tyy+tzz);
  res.coeffRef(0,1) = txy-twz;
  res.coeffRef(0,2) = txz+twy;
  res.coeffRef(1,0) = txy+twz;
  res.coeffRef(1,1) = Scalar(1)-(txx+tzz);
  res.coeffRef(1,2) = tyz-twx;
  res.coeffRef(2,0) = txz-twy;
  res.coeffRef(2,1) = tyz+twx;
  res.coeffRef(2,2) = Scalar(1)-(txx+tyy);

  return res;
}

// Assembly:
movq %rdi, %rax
movsd (%rsi), %xmm2
movapd %xmm2, %xmm0
addsd %xmm2, %xmm0
movsd 0x18(%rsi), %xmm5
movapd %xmm2, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm5, %xmm0
movupd 0x8(%rsi), %xmm6
movapd %xmm6, %xmm3
addpd %xmm6, %xmm3
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
mulpd %xmm3, %xmm5
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm3, %xmm2
movapd %xmm6, %xmm4
mulpd %xmm3, %xmm4
unpckhpd %xmm3, %xmm3            # xmm3 = xmm3[1,1]
mulsd %xmm6, %xmm3
movapd %xmm4, %xmm7
unpckhpd %xmm4, %xmm7            # xmm7 = xmm7[1],xmm4[1]
movapd %xmm4, %xmm8
addsd %xmm7, %xmm8
movsd 0xe349(%rip), %xmm6     # 0x1f060
movapd %xmm6, %xmm9
subsd %xmm8, %xmm9
movsd %xmm9, (%rdi)
movapd %xmm3, %xmm8
subsd %xmm0, %xmm8
movapd %xmm2, %xmm9
shufpd $0x1, %xmm2, %xmm9      # xmm9 = xmm9[1],xmm2[0]
subpd %xmm5, %xmm9
unpcklpd %xmm5, %xmm0            # xmm0 = xmm0[0],xmm5[0]
unpckhpd %xmm5, %xmm5            # xmm5 = xmm5[1,1]
addsd %xmm2, %xmm5
movsd %xmm5, 0x8(%rdi)
addsd %xmm1, %xmm7
movapd %xmm6, %xmm5
subsd %xmm7, %xmm5
movsd %xmm5, 0x20(%rdi)
movsd %xmm8, 0x38(%rdi)
movupd %xmm9, 0x10(%rdi)
shufpd $0x2, %xmm2, %xmm3      # xmm3 = xmm3[0],xmm2[1]
addpd %xmm3, %xmm0
movupd %xmm0, 0x28(%rdi)
addsd %xmm1, %xmm4
subsd %xmm4, %xmm6
movsd %xmm6, 0x40(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::parse[abi:cxx11](picojson::value&, std::istream&)
inline std::string parse(value& out, std::istream& is) {
    std::string err;
    parse(out, std::istreambuf_iterator<char>(is.rdbuf()),
	  std::istreambuf_iterator<char>(), &err);
    return err;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rdx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdx,%rax), %rcx
leaq 0x18(%rsp), %rax
movq %rcx, (%rax)
orl $-0x1, 0x8(%rax)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rsi, %rdi
orl $-0x1, 0x8(%rdx)
movq %rax, %rsi
movq %rbx, %rcx
callq 0x10e1c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x56e8
movq %r14, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x70, %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 0x10ec3
testq %rbx, %rbx
je 0x10eb1
testb %al, %al
jne 0x10eb1
movq %rsp, %r14
movl 0x24(%r14), %ecx
leaq 0xfcac(%rip), %rdx      # 0x20b1c
leaq 0x30(%rsp), %r15
pushq $0x40
popq %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x5560
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56a0
movq %r14, %rdi
callq 0x110a0
cmpl $-0x1, %eax
je 0x10eb1
cmpl $0xa, %eax
je 0x10eb1
cmpl $0x20, %eax
jl 0x10e8d
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5320
jmp 0x10e8d
movq %rsp, %rdi
callq 0x110ec
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x110c1
movq %rbx, %rdi
callq 0x11f1e
cmpb $0xa, %al
jne 0x110b9
incl 0x24(%rbx)
movq %rbx, %rdi
callq 0x11f08
leaq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x11f4e
testb %al, %al
je 0x110da
movb $0x0, 0x20(%rbx)
pushq $-0x1
popq %rax
jmp 0x110e9
movb $0x1, 0x20(%rbx)
movq %rbx, %rdi
callq 0x11f1e
movzbl %al, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::cur() const
Iter cur() const {
      if (consumed_) {
        input<Iter> *self = const_cast<input<Iter>*>(this);
        self->consumed_ = false;
        ++self->cur_;
      }
      return cur_;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0x11102
movb $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x11f08
movq (%rbx), %rax
movl 0x8(%rbx), %edx
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::skip_ws()
void skip_ws() {
      while (1) {
	int ch = getc();
	if (! (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')) {
	  ungetc();
	  break;
	}
      }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100002600, %r14      # imm = 0x100002600
movq %rbx, %rdi
callq 0x110a0
cmpl $0x20, %eax
ja 0x11130
movl %eax, %eax
btq %rax, %r14
jb 0x1111b
movb $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool match(const std::string& pattern) {
      for (std::string::const_iterator pi(pattern.begin());
	   pi != pattern.end();
	   ++pi) {
	if (getc() != *pi) {
	  ungetc();
	  return false;
	}
      }
      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movq %rcx, %r15
movq (%r14), %r12
addq 0x8(%r14), %r12
cmpq %r12, %rcx
je 0x11174
movq %rbx, %rdi
callq 0x110a0
movsbl (%r15), %edx
leaq 0x1(%r15), %rcx
cmpl %edx, %eax
je 0x1114d
movb $0x0, 0x20(%rbx)
cmpq %r12, %r15
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::_parse_array<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_array(Context& ctx, input<Iter>& in) {
    if (! ctx.parse_array_start()) {
      return false;
    }
    size_t idx = 0;
    if (in.expect(']')) {
      return ctx.parse_array_stop(idx);
    }
    do {
      if (! ctx.parse_array_item(in, idx)) {
	return false;
      }
      idx++;
    } while (in.expect(','));
    return in.expect(']') && ctx.parse_array_stop(idx);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1171c
testb %al, %al
je 0x112b7
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x11762
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x112b9
xorl %r15d, %r15d
pushq $0x2c
popq %rbp
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1178e
testb %al, %al
je 0x112b7
incq %r15
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11762
testb %al, %al
jne 0x1127f
pushq $0x5d
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11762
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x119f4
testb %al, %al
je 0x11389
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x11762
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1138b
leaq 0x18(%rsp), %r12
pushq $0x22
popq %rbp
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x11762
testb %al, %al
je 0x1137f
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11504
testb %al, %al
je 0x1137f
movq %rbx, %rdi
pushq $0x3a
popq %rsi
callq 0x11762
testb %al, %al
je 0x1137f
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x11a42
movl %eax, %r13d
movq %r15, %rdi
callq 0x56e8
testb %r13b, %r13b
je 0x11389
movq %rbx, %rdi
pushq $0x2c
popq %rsi
callq 0x11762
testb %al, %al
jne 0x11309
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x11762
jmp 0x1138b
leaq 0x8(%rsp), %rdi
callq 0x56e8
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x56e8
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> picojson::_parse_number<std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&)
inline std::string _parse_number(input<Iter>& in) {
    std::string num_str;
    while (1) {
      int ch = in.getc();
      if (('0' <= ch && ch <= '9') || ch == '+' || ch == '-'
          || ch == 'e' || ch == 'E') {
        num_str.push_back(ch);
      } else if (ch == '.') {
#if PICOJSON_USE_LOCALE
        num_str += localeconv()->decimal_point;
#else
        num_str.push_back('.');
#endif
      } else {
	in.ungetc();
	break;
      }
    }
    return num_str;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movabsq $0x400000004000005, %r15 # imm = 0x400000004000005
movq %r14, %rdi
callq 0x110a0
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x113f2
leal -0x2b(%rax), %ecx
cmpl $0x3a, %ecx
ja 0x11417
btq %rcx, %r15
jae 0x113ff
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5320
jmp 0x113d4
cmpq $0x3, %rcx
jne 0x11417
callq 0x56b0
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5690
jmp 0x113d4
movb $0x0, 0x20(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x56e8
movq %r14, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: picojson::value::value(int, bool)
inline value::value(int type, bool) : type_(type) {
    switch (type) {
#define INIT(p, v) case p##type: u_.p = v; break
      INIT(boolean_, false);
      INIT(number_, 0.0);
#ifdef PICOJSON_USE_INT64
      INIT(int64_, 0);
#endif
      INIT(string_, new std::string());
      INIT(array_, new array());
      INIT(object_, new object());
#undef INIT
    default: break;
    }
  }

// Assembly:
movl %esi, (%rdi)
decl %esi
cmpl $0x4, %esi
ja 0x11503
pushq %rbx
movq %rdi, %rbx
leaq 0xecea(%rip), %rax      # 0x20180
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x0, 0x8(%rbx)
jmp 0x11502
pushq $0x30
popq %rdi
callq 0x5390
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andq $0x0, 0x28(%rax)
jmp 0x114f7
pushq $0x20
popq %rdi
callq 0x5390
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
jmp 0x114f7
pushq $0x18
popq %rdi
callq 0x5390
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
jmp 0x11502
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xec7e(%rip), %r15      # 0x20194
movq %rbx, %rdi
callq 0x110a0
cmpl $0x1f, %eax
jle 0x115a1
cmpl $0x5c, %eax
je 0x1153a
cmpl $0x22, %eax
je 0x115a9
movsbl %al, %esi
movq %r14, %rdi
callq 0x5320
jmp 0x11516
movq %rbx, %rdi
callq 0x110a0
movl %eax, %ecx
xorl %eax, %eax
leal -0x6e(%rcx), %edx
cmpl $0x7, %edx
jbe 0x1156b
cmpl $0x22, %ecx
je 0x11591
cmpl $0x2f, %ecx
je 0x11599
cmpl $0x66, %ecx
je 0x11595
cmpl $0x62, %ecx
je 0x1159d
cmpl $0x5c, %ecx
jne 0x115ab
movb $0x5c, %al
jmp 0x1152d
movslq (%r15,%rdx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movb $0xa, %al
jmp 0x1152d
movb $0xd, %al
jmp 0x1152d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x115b1
testb %al, %al
jne 0x11516
jmp 0x115a5
movb $0x9, %al
jmp 0x1152d
movb $0x22, %al
jmp 0x1152d
movb $0xc, %al
jmp 0x1152d
movb $0x2f, %al
jmp 0x1152d
movb $0x8, %al
jmp 0x1152d
movb $0x0, 0x20(%rbx)
xorl %eax, %eax
jmp 0x115ab
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: bool picojson::_parse_codepoint<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_codepoint(String& out, input<Iter>& in) {
    int uni_ch;
    if ((uni_ch = _parse_quadhex(in)) == -1) {
      return false;
    }
    if (0xd800 <= uni_ch && uni_ch <= 0xdfff) {
      if (0xdc00 <= uni_ch) {
	// a second 16-bit of a surrogate pair appeared
	return false;
      }
      // first 16-bit of surrogate pair, get the next one
      if (in.getc() != '\\' || in.getc() != 'u') {
	in.ungetc();
	return false;
      }
      int second = _parse_quadhex(in);
      if (! (0xdc00 <= second && second <= 0xdfff)) {
	return false;
      }
      uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
      uni_ch += 0x10000;
    }
    if (uni_ch < 0x80) {
      out.push_back(uni_ch);
    } else {
      if (uni_ch < 0x800) {
	out.push_back(0xc0 | (uni_ch >> 6));
      } else {
	if (uni_ch < 0x10000) {
	  out.push_back(0xe0 | (uni_ch >> 12));
	} else {
	  out.push_back(0xf0 | (uni_ch >> 18));
	  out.push_back(0x80 | ((uni_ch >> 12) & 0x3f));
	}
	out.push_back(0x80 | ((uni_ch >> 6) & 0x3f));
      }
      out.push_back(0x80 | (uni_ch & 0x3f));
    }
    return true;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x116b6
cmpl $-0x1, %eax
je 0x11646
movl %eax, %r14d
andl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xd800, %eax           # imm = 0xD800
jne 0x11628
cmpl $0xdbff, %r14d          # imm = 0xDBFF
ja 0x11646
movq %r15, %rdi
callq 0x110a0
cmpl $0x5c, %eax
jne 0x11641
movq %r15, %rdi
callq 0x110a0
cmpl $0x75, %eax
jne 0x11641
movq %r15, %rdi
callq 0x116b6
movl %eax, %ecx
andl $0xfffffc00, %ecx       # imm = 0xFFFFFC00
cmpl $0xdc00, %ecx           # imm = 0xDC00
jne 0x11646
shll $0xa, %r14d
andl $0x3ff, %eax            # imm = 0x3FF
addl %eax, %r14d
addl $0xfca10000, %r14d      # imm = 0xFCA10000
jmp 0x1165d
cmpl $0x7f, %r14d
jle 0x116a2
cmpl $0x7ff, %r14d           # imm = 0x7FF
ja 0x1164a
movl %r14d, %eax
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x1168f
movb $0x0, 0x20(%r15)
xorl %eax, %eax
jmp 0x116b0
cmpl $0xffff, %r14d          # imm = 0xFFFF
ja 0x1165d
movl %r14d, %eax
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x1167a
movl %r14d, %eax
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5320
movl %r14d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5320
movl %r14d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5320
andb $0x3f, %r14b
orb $-0x80, %r14b
movsbl %r14b, %esi
movq %rbx, %rdi
callq 0x5320
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/picojson.h
// Function: int picojson::_parse_quadhex<std::istreambuf_iterator<char, std::char_traits<char>>>(picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>&)
inline int _parse_quadhex(input<Iter> &in) {
    int uni_ch = 0, hex;
    for (int i = 0; i < 4; i++) {
      if ((hex = in.getc()) == -1) {
	return -1;
      }
      if ('0' <= hex && hex <= '9') {
	hex -= '0';
      } else if ('A' <= hex && hex <= 'F') {
	hex -= 'A' - 0xa;
      } else if ('a' <= hex && hex <= 'f') {
	hex -= 'a' - 0xa;
      } else {
	in.ungetc();
	return -1;
      }
      uni_ch = uni_ch * 16 + hex;
    }
    return uni_ch;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebp, %ebp
pushq $0x4
popq %r15
pushq $-0x1
popq %rbx
subl $0x1, %r15d
jb 0x11705
movq %r14, %rdi
callq 0x110a0
cmpl $-0x1, %eax
je 0x11707
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x116fe
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0x116f1
addl $-0x37, %eax
jmp 0x116fc
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0x11714
addl $-0x57, %eax
movl %eax, %ecx
shll $0x4, %ebp
addl %ecx, %ebp
jmp 0x116c9
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, 0x20(%r14)
jmp 0x11707
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x1110a
movq %r14, %rdi
callq 0x110a0
cmpl %ebx, %eax
je 0x11781
movb $0x0, 0x20(%r14)
cmpl %ebx, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
movq (%rdi), %rdi
callq 0xfbd6
movq %rax, %r14
movq %rsp, %rsi
andl $0x0, (%rsi)
movq %rax, %rdi
callq 0x117f2
movq %rsp, %r15
movq %r15, %rdi
callq 0x6fb4
movq 0x8(%r14), %rax
addq $-0x10, %rax
movq %rax, (%r15)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x10ec3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6fb4
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x12292
cmpl $0x4, %eax
je 0x12279
cmpl $0x3, %eax
jne 0x122af
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x54c0
jmp 0x122a9
pushq $0x18
popq %rdi
callq 0x5390
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x122e2
jmp 0x122a9
pushq $0x30
popq %rdi
callq 0x5390
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x12018
movq %r15, 0x8(%rbx)
jmp 0x122b7
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
jmp 0x122d0
movq %rax, %rbx
pushq $0x30
jmp 0x122d0
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x53a0
movq %rbx, %rdi
callq 0x5640
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
// Function: void boost::numeric::odeint::dense_output_runge_kutta<boost::numeric::odeint::controlled_runge_kutta<boost::numeric::odeint::runge_kutta_dopri5<std::array<double, 14ul>, double, std::array<double, 14ul>, double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations, boost::numeric::odeint::initially_resizer>, boost::numeric::odeint::default_error_checker<double, boost::numeric::odeint::array_algebra, boost::numeric::odeint::default_operations>, boost::numeric::odeint::default_step_adjuster<double, double>, boost::numeric::odeint::initially_resizer, boost::numeric::odeint::explicit_error_stepper_fsal_tag>, boost::numeric::odeint::explicit_controlled_stepper_fsal_tag>::initialize<std::array<double, 14ul>>(std::array<double, 14ul> const&, double, double)
void initialize( const StateType &x0 , time_type t0 , time_type dt0 )
    {
        m_resizer.adjust_size( x0 , detail::bind( &dense_output_stepper_type::template resize< StateType > , detail::ref( *this ) , detail::_1 ) );
        boost::numeric::odeint::copy( x0 , get_current_state() );
        m_t = t0;
        m_dt = dt0;
        m_is_deriv_initialized = false;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
addq $0x588, %rdi            # imm = 0x588
leaq 0x222(%rip), %rax       # 0x13dec
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
andq $0x0, 0x8(%rdx)
movq %r14, 0x10(%rdx)
callq 0x13dd8
leaq 0x600(%r14), %rax
leaq 0x590(%r14), %rdi
cmpb $0x0, 0x589(%r14)
cmoveq %rax, %rdi
pushq $0x70
popq %rdx
movq %rbx, %rsi
callq 0x5590
movsd (%rsp), %xmm0
movsd %xmm0, 0x750(%r14)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x760(%r14)
movb $0x0, 0x768(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl (%rdi), %edx
movl 0x4(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl %edx, %eax
jge 0x141d4
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
leaq 0xdc7b(%rip), %rsi      # 0x21e56
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x50d0
leaq 0x18(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6c7e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x14dfa
leaq 0xdc8a(%rip), %rax      # 0x21e9d
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xdcb1(%rip), %rax      # 0x21ed3
movq %rax, 0x8(%rsi)
movq $0x69, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x14dac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x53f0
jmp 0x1424a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x56e8
movq %rbx, %rdi
callq 0x5640
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x40, %rsp
movq %r8, %rbx
movsd 0x10(%rdi), %xmm1
andpd 0xace7(%rip), %xmm0     # 0x1f050
mulsd 0x18(%rdi), %xmm0
movups (%rdi), %xmm2
movaps %xmm2, 0x20(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd %xmm0, 0x38(%rsp)
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r8, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x14cfc
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
jmp 0x14d40
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
// Function: boost::numeric::odeint::default_step_adjuster<double, double>::decrease_step(double, double, int) const
time_type decrease_step(time_type dt, const value_type error, const int error_order) const
    {
        // returns the decreased time step
        BOOST_USING_STD_MIN();
        BOOST_USING_STD_MAX();
        using std::pow;

        dt *= max
        BOOST_PREVENT_MACRO_SUBSTITUTION(
                static_cast<value_type>( static_cast<value_type>(9) / static_cast<value_type>(10) *
                                         pow(error, static_cast<value_type>(-1) / (error_order - 1))),
                static_cast<value_type>( static_cast<value_type>(1) / static_cast<value_type> (5)));
        if(m_max_dt != static_cast<time_type >(0))
            // limit to maximal stepsize even when decreasing
            dt = detail::min_abs(dt, m_max_dt);
        return dt;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movapd %xmm1, %xmm2
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
decl %esi
cvtsi2sd %esi, %xmm0
movsd 0xbb30(%rip), %xmm1     # 0x1ff00
divsd %xmm0, %xmm1
movapd %xmm2, %xmm0
callq 0x5630
movapd %xmm0, %xmm1
mulsd 0xbb4f(%rip), %xmm1     # 0x1ff38
movsd 0xbb4f(%rip), %xmm0     # 0x1ff40
maxsd %xmm1, %xmm0
mulsd 0x8(%rsp), %xmm0
movsd (%rbx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm2
jne 0x1440b
jnp 0x1442c
movapd %xmm2, %xmm3
minsd %xmm0, %xmm3
maxsd %xmm0, %xmm2
cmpltsd %xmm0, %xmm1
andpd %xmm1, %xmm3
andnpd %xmm2, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
// Function: boost::numeric::odeint::default_step_adjuster<double, double>::increase_step(double, double, int) const
time_type increase_step(time_type dt, value_type error, const int stepper_order) const
    {
        // returns the increased time step
        BOOST_USING_STD_MIN();
        BOOST_USING_STD_MAX();
        using std::pow;

        // adjust the size if dt is smaller than max_dt (providede max_dt is not zero)
        if(error < 0.5)
        {
            // error should be > 0
            error = max BOOST_PREVENT_MACRO_SUBSTITUTION (
                    static_cast<value_type>( pow( static_cast<value_type>(5.0) , -static_cast<value_type>(stepper_order) ) ) ,
                    error);
            time_type dt_old = dt;
            //error too small - increase dt and keep the evolution and limit scaling factor to 5.0
            dt *= static_cast<value_type>(9)/static_cast<value_type>(10) *
                  pow(error, static_cast<value_type>(-1) / stepper_order);
            if(m_max_dt != static_cast<time_type >(0))
                // limit to maximal stepsize
                dt = detail::min_abs(dt, m_max_dt);
        }
        return dt;
    }

// Assembly:
movapd %xmm0, %xmm3
movsd 0xb9fa(%rip), %xmm0     # 0x1fe38
ucomisd %xmm1, %xmm0
jbe 0x144e7
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cvtsi2sd %esi, %xmm0
movapd %xmm0, 0x10(%rsp)
movsd %xmm1, (%rsp)
movapd 0xaba9(%rip), %xmm1     # 0x1f010
xorpd %xmm0, %xmm1
movsd 0xbad5(%rip), %xmm0     # 0x1ff48
movsd %xmm3, 0x8(%rsp)
callq 0x5630
movsd (%rsp), %xmm2
maxsd %xmm0, %xmm2
movsd 0xba71(%rip), %xmm1     # 0x1ff00
divsd 0x10(%rsp), %xmm1
movapd %xmm2, %xmm0
callq 0x5630
movsd 0x8(%rsp), %xmm3
mulsd 0xba8c(%rip), %xmm0     # 0x1ff38
mulsd %xmm0, %xmm3
movsd (%rbx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
leaq 0x20(%rsp), %rsp
popq %rbx
jne 0x144c6
jnp 0x144e7
movapd %xmm1, %xmm2
minsd %xmm3, %xmm2
maxsd %xmm3, %xmm1
cmpltsd %xmm3, %xmm0
andpd %xmm0, %xmm2
andnpd %xmm1, %xmm0
orpd %xmm2, %xmm0
movapd %xmm0, %xmm3
movapd %xmm3, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/algebra/array_algebra.hpp
// Function: boost::numeric::odeint::norm_result_type<std::array<double, 14ul>, void>::type boost::numeric::odeint::array_algebra::norm_inf<std::array, double, 14ul>(std::array<double, 14ul> const&)
static typename norm_result_type< Array< T , dim > >::type norm_inf( const Array< T , dim > &s )
    {
        BOOST_USING_STD_MAX();
        using std::abs;
        typedef typename norm_result_type< Array< T , dim > >::type result_type;
        result_type init = static_cast< result_type >( 0 );
        for( size_t i=0 ; i<dim ; ++i )
            init = max BOOST_PREVENT_MACRO_SUBSTITUTION ( init , static_cast< result_type >(abs(s[i])) );
        return init;
    }

// Assembly:
xorpd %xmm0, %xmm0
xorl %eax, %eax
movapd 0xa302(%rip), %xmm1     # 0x1f050
cmpq $0xe, %rax
je 0x14d6a
movsd (%rdi,%rax,8), %xmm2
andpd %xmm1, %xmm2
maxsd %xmm0, %xmm2
incq %rax
movapd %xmm2, %xmm0
jmp 0x14d4e
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Geometry/Quaternion.h
// Function: Eigen::QuaternionBase<Eigen::Quaternion<double, 0>>::operator=(Eigen::AngleAxis<double> const&)
EIGEN_STRONG_INLINE Derived& QuaternionBase<Derived>::operator=(const AngleAxisType& aa)
{
  using std::cos;
  using std::sin;
  Scalar ha = Scalar(0.5)*aa.angle(); // Scalar(0.5) to suppress precision loss warnings
  this->w() = cos(ha);
  this->vec() = sin(ha) * aa.axis();
  return derived();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x18(%rsi), %xmm0
mulsd 0xa7de(%rip), %xmm0     # 0x1fe38
movsd %xmm0, 0x8(%rsp)
callq 0x5680
movsd %xmm0, 0x18(%r14)
movsd 0x8(%rsp), %xmm0
callq 0x50e0
leaq 0x10(%rsp), %r15
movq %rbx, (%r15)
movsd %xmm0, 0x8(%r15)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x156ac
movq %rbx, %rdi
movq %r15, %rsi
callq 0x15802
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movslq %esi, %rbx
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
xorl %r12d, %r12d
movsd %xmm0, 0x10(%rsp)
movq %r12, %r15
movq 0x8(%r14), %rax
decq %rax
cmpq %r15, %rax
jle 0x15fe0
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6548
movsd 0x10(%rsp), %xmm0
ucomisd (%rax), %xmm0
jb 0x15f21
leaq 0x1(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6548
movsd (%rax), %xmm0
ucomisd 0x10(%rsp), %xmm0
ja 0x15f26
incq %r15
jmp 0x15edb
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6548
movsd 0x10(%rsp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x6548
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6548
movsd 0x8(%rsp), %xmm1
subsd (%rax), %xmm1
movsd 0x18(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6548
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6548
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6548
movsd 0x8(%rsp), %xmm1
subsd (%rax), %xmm1
mulsd 0x18(%rsp), %xmm1
addsd 0x20(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
jmp 0x15ed8
xorl %r15d, %r15d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6548
movsd (%rax), %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x16029
movq 0x8(%r14), %rsi
decq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x6548
movsd 0x10(%rsp), %xmm0
ucomisd (%rax), %xmm0
movsd 0x8(%rsp), %xmm0
jb 0x1603b
movq 0x8(%r14), %r15
decq %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6548
movsd (%rax), %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq