LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6610
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6210
movq %rax, -0x68(%rbp)
jmp 0x212fc
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x21400
leaq -0x50(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x21440
movq -0x70(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x213a0
movl %edx, -0x8c(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x2134a
movl -0x8c(%rbp), %eax
movq -0x88(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movl %eax, -0x58(%rbp)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2138a
jmp 0x21381
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x68a8
jmp 0x21397
movq -0x80(%rbp), %rdi
callq 0x68a8
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x67a0
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x215a0
movq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x215f0
testb $0x1, %al
jne 0x21563
cmpq $0x0, -0x30(%rbp)
je 0x21563
leaq -0xa0(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x21af0
movq -0xc0(%rbp), %rdi
movl %eax, %ecx
movl $0x40, %esi
leaq 0x327a4(%rip), %rdx     # 0x53cac
movb $0x0, %al
callq 0x66c0
leaq -0xa0(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x6600
leaq -0x58(%rbp), %rdi
callq 0x21b10
movl %eax, -0xa4(%rbp)
cmpl $-0x1, -0xa4(%rbp)
je 0x21540
cmpl $0xa, -0xa4(%rbp)
jne 0x21542
jmp 0x21561
cmpl $0x20, -0xa4(%rbp)
jl 0x2155d
movq -0x30(%rbp), %rdi
movl -0xa4(%rbp), %eax
movsbl %al, %esi
callq 0x63f0
jmp 0x2155f
jmp 0x2151f
jmp 0x21563
leaq -0x58(%rbp), %rdi
callq 0x21ba0
movl %edx, -0xb0(%rbp)
movq %rax, -0xb8(%rbp)
movl -0xb0(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x20(%rax)
je 0x21b51
movq -0x18(%rbp), %rdi
callq 0x24590
movsbl %al, %eax
cmpl $0xa, %eax
jne 0x21b48
movq -0x18(%rbp), %rax
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rdi
callq 0x245c0
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
callq 0x245f0
testb $0x1, %al
jne 0x21b67
jmp 0x21b78
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x21b90
movq -0x18(%rbp), %rdi
movb $0x1, 0x20(%rdi)
callq 0x24590
movsbl %al, %eax
andl $0xff, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0x20(%rax)
je 0x21bd3
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x20(%rbp), %rdi
callq 0x245c0
movq -0x28(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21b10
movl %eax, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
je 0x21c33
cmpl $0x9, -0xc(%rbp)
je 0x21c33
cmpl $0xa, -0xc(%rbp)
je 0x21c33
cmpl $0xd, -0xc(%rbp)
je 0x21c33
movq -0x18(%rbp), %rdi
callq 0x22000
jmp 0x21c35
jmp 0x21c04
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6440
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6820
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22150
testb $0x1, %al
jne 0x21c85
jmp 0x21cc3
movq -0x30(%rbp), %rdi
callq 0x21b10
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x22190
movq %rax, %rcx
movl -0x34(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x21cb6
movq -0x30(%rbp), %rdi
callq 0x22000
movb $0x0, -0x1(%rbp)
jmp 0x21cc7
jmp 0x21cb8
leaq -0x20(%rbp), %rdi
callq 0x221b0
jmp 0x21c65
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x228b0
testb $0x1, %al
jne 0x21e06
movb $0x0, -0x1(%rbp)
jmp 0x21ea5
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x5d, %esi
callq 0x22900
testb $0x1, %al
jne 0x21e22
jmp 0x21e36
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22950
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x21ea5
jmp 0x21e38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x22970
testb $0x1, %al
jne 0x21e53
movb $0x0, -0x1(%rbp)
jmp 0x21ea5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x22900
testb $0x1, %al
jne 0x21e38
movq -0x18(%rbp), %rdi
movl $0x5d, %esi
callq 0x22900
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x21e8d
jmp 0x21e9d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x22950
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x232f0
testb $0x1, %al
jne 0x21ed6
movb $0x0, -0x1(%rbp)
jmp 0x21fe7
movq -0x18(%rbp), %rdi
movl $0x7d, %esi
callq 0x22900
testb $0x1, %al
jne 0x21eea
jmp 0x21ef3
movb $0x1, -0x1(%rbp)
jmp 0x21fe7
jmp 0x21ef5
leaq -0x38(%rbp), %rdi
callq 0x6610
movq -0x18(%rbp), %rdi
movl $0x22, %esi
callq 0x22900
movb %al, -0x49(%rbp)
jmp 0x21f11
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x21f1a
jmp 0x21f51
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x223f0
movb %al, -0x4a(%rbp)
jmp 0x21f2c
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x21f35
jmp 0x21f51
movq -0x18(%rbp), %rdi
movl $0x3a, %esi
callq 0x22900
movb %al, -0x4b(%rbp)
jmp 0x21f48
movb -0x4b(%rbp), %al
testb $0x1, %al
jne 0x21f75
jmp 0x21f51
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x21fa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x68a8
jmp 0x21ff2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x23340
movb %al, -0x4c(%rbp)
jmp 0x21f8b
movb -0x4c(%rbp), %al
testb $0x1, %al
jne 0x21fa1
jmp 0x21f94
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0x21fa8
movl $0x0, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x68a8
movl -0x48(%rbp), %eax
testl %eax, %eax
je 0x21fbc
jmp 0x21fba
jmp 0x21fe7
jmp 0x21fbe
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x22900
testb $0x1, %al
jne 0x21ef5
movq -0x18(%rbp), %rdi
movl $0x7d, %esi
callq 0x22900
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x6610
jmp 0x22046
movq -0x10(%rbp), %rdi
callq 0x21b10
movl %eax, -0x3c(%rbp)
jmp 0x22054
movl -0x3c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x30, %eax
cmpl -0x18(%rbp), %eax
jg 0x2206a
cmpl $0x39, -0x18(%rbp)
jle 0x22082
cmpl $0x2b, -0x18(%rbp)
je 0x22082
cmpl $0x2d, -0x18(%rbp)
je 0x22082
cmpl $0x65, -0x18(%rbp)
je 0x22082
cmpl $0x45, -0x18(%rbp)
jne 0x220aa
movq -0x38(%rbp), %rdi
movsbl -0x18(%rbp), %esi
callq 0x63f0
jmp 0x22091
jmp 0x220d2
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x68a8
jmp 0x220f4
cmpl $0x2e, -0x18(%rbp)
jne 0x220c5
callq 0x6850
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x6450
jmp 0x220c3
jmp 0x220d0
movq -0x10(%rbp), %rdi
callq 0x22000
jmp 0x220d7
jmp 0x220d2
jmp 0x22044
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x220ea
movq -0x38(%rbp), %rdi
callq 0x68a8
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x223e5
movq -0x18(%rbp), %rax
leaq 0x30eae(%rip), %rcx     # 0x531e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movb $0x0, 0x8(%rax)
jmp 0x223e7
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x223e7
movl $0x20, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x6610
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x223e7
movl $0x18, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x62a0
movq -0x30(%rbp), %rdi
callq 0x22550
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x223e7
movl $0x30, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x62a0
movq -0x38(%rbp), %rdi
callq 0x1dc00
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x223e7
jmp 0x223e7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21b10
movl %eax, -0x1c(%rbp)
cmpl $0x20, -0x1c(%rbp)
jge 0x22424
movq -0x18(%rbp), %rdi
callq 0x22000
movb $0x0, -0x1(%rbp)
jmp 0x2253c
cmpl $0x22, -0x1c(%rbp)
jne 0x22433
movb $0x1, -0x1(%rbp)
jmp 0x2253c
cmpl $0x5c, -0x1c(%rbp)
jne 0x22524
movq -0x18(%rbp), %rdi
callq 0x21b10
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x22457
movb $0x0, -0x1(%rbp)
jmp 0x2253c
movl -0x1c(%rbp), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x53, %eax
ja 0x2251c
movq -0x28(%rbp), %rax
leaq 0x30d7d(%rip), %rcx     # 0x531f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movl $0x22, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0x5c, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x63f0
jmp 0x22522
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22620
testb $0x1, %al
jne 0x2251a
movb $0x0, -0x1(%rbp)
jmp 0x2253c
jmp 0x22522
movb $0x0, -0x1(%rbp)
jmp 0x2253c
jmp 0x22533
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movsbl %al, %esi
callq 0x63f0
jmp 0x22535
jmp 0x22537
jmp 0x22400
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x22892
movq -0x10(%rbp), %rdi
callq 0x21b10
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x22811
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22898
movl $0x30, %eax
cmpl -0x18(%rbp), %eax
jg 0x2282c
cmpl $0x39, -0x18(%rbp)
jg 0x2282c
movl -0x18(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
jmp 0x22878
movl $0x41, %eax
cmpl -0x18(%rbp), %eax
jg 0x22847
cmpl $0x46, -0x18(%rbp)
jg 0x22847
movl -0x18(%rbp), %eax
subl $0x37, %eax
movl %eax, -0x18(%rbp)
jmp 0x22876
movl $0x61, %eax
cmpl -0x18(%rbp), %eax
jg 0x22862
cmpl $0x66, -0x18(%rbp)
jg 0x22862
movl -0x18(%rbp), %eax
subl $0x57, %eax
movl %eax, -0x18(%rbp)
jmp 0x22874
movq -0x10(%rbp), %rdi
callq 0x22000
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x22898
jmp 0x22876
jmp 0x22878
movl -0x14(%rbp), %eax
shll $0x4, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x227ea
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x21bf0
movq -0x20(%rbp), %rdi
callq 0x21b10
cmpl -0x14(%rbp), %eax
je 0x22939
movq -0x20(%rbp), %rdi
callq 0x22000
movb $0x0, -0x1(%rbp)
jmp 0x2293d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1dd90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1d6d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x22a10
jmp 0x229b8
leaq -0x30(%rbp), %rdi
callq 0xb6c0
movq -0x20(%rbp), %rdi
callq 0x22a40
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x21470
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x215f0
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb6c0
movq -0x38(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x3, %eax
je 0x25117
jmp 0x250fc
movl -0x20(%rbp), %eax
subl $0x4, %eax
je 0x2516a
jmp 0x25106
movl -0x20(%rbp), %eax
subl $0x5, %eax
je 0x251b7
jmp 0x25204
movl $0x20, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x61f0
jmp 0x2513a
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x25214
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x6490
jmp 0x2521a
movl $0x18, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x25230
jmp 0x2518d
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x25214
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x6490
jmp 0x2521a
movl $0x30, %edi
callq 0x6480
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1dad0
jmp 0x251da
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x25214
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x6490
jmp 0x2521a
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/PlainObjectBase.h
// Function: void Eigen::PlainObjectBase<Eigen::Matrix<double, 4, 1, 0, 4, 1>>::writePacket<1>(long, long, double vector[2] const&)
EIGEN_STRONG_INLINE void writePacket(Index rowId, Index colId, const PacketScalar& val)
    {
      internal::pstoret<Scalar, PacketScalar, StoreMode>
              (m_storage.data() + (Flags & RowMajorBit
                                   ? colId + rowId * m_storage.cols()
                                   : rowId + colId * m_storage.rows()), val);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27cb0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x27940
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x9210
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/PlainObjectBase.h
// Function: double vector[2] Eigen::PlainObjectBase<Eigen::Matrix<double, 4, 1, 0, 4, 1>>::packet<1>(long, long) const
EIGEN_STRONG_INLINE PacketScalar packet(Index rowId, Index colId) const
    {
      return internal::ploadt<PacketScalar, LoadMode>
               (m_storage.data() + (Flags & RowMajorBit
                                   ? colId + rowId * m_storage.cols()
                                   : rowId + colId * m_storage.rows()));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27cc0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x27940
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x9290
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
addq $0x588, %rax            # imm = 0x588
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq 0x5a2(%rip), %rax       # 0x2d1f0
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x2d2d0
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movq 0x4c322(%rip), %rcx     # 0x78f98
callq 0x2d1b0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x2d160
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x2d330
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x2d300
movq -0x58(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x750(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x760(%rax)
movb $0x0, 0x768(%rax)
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: istellartech[P]OpenTsiolkovsky/./boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
// Function: bool 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>::resize<std::array<double, 14ul>>(std::array<double, 14ul> const&)
bool resize( const StateIn &x )
    {
        bool resized = false;
        resized |= adjust_size_by_resizeability( m_x1 , x , typename is_resizeable<state_type>::type() );
        resized |= adjust_size_by_resizeability( m_x2 , x , typename is_resizeable<state_type>::type() );
        resized |= adjust_size_by_resizeability( m_dxdt1 , x , typename is_resizeable<deriv_type>::type() );
        resized |= adjust_size_by_resizeability( m_dxdt2 , x , typename is_resizeable<deriv_type>::type() );
        return resized;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x590, %rdi            # imm = 0x590
movq -0x10(%rbp), %rsi
callq 0x2d8a0
movq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
addq $0x600, %rdi            # imm = 0x600
movq -0x10(%rbp), %rsi
callq 0x2d8a0
movq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
addq $0x670, %rdi            # imm = 0x670
movq -0x10(%rbp), %rsi
callq 0x2d8a0
movq -0x20(%rbp), %rdi
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
addq $0x6e0, %rdi            # imm = 0x6E0
movq -0x10(%rbp), %rsi
callq 0x2d8a0
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x138(%rbp)
movl 0x4(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
cmpl (%rcx), %eax
jl 0x2e9d4
movq -0x138(%rbp), %rax
movl (%rax), %edx
leaq 0x2700b(%rip), %rsi     # 0x558e8
xorl %eax, %eax
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x6110
leaq -0x101(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x67b0
movq -0x148(%rbp), %rsi
movq -0x140(%rbp), %rdx
leaq -0x100(%rbp), %rdi
callq 0xac00
jmp 0x2e921
leaq -0xe0(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x31290
jmp 0x2e936
leaq 0x26ff2(%rip), %rsi     # 0x5592f
leaq 0x27021(%rip), %rcx     # 0x55965
leaq -0x130(%rbp), %rdi
movq %rdi, -0x150(%rbp)
movl $0x69, %edx
xorl %r8d, %r8d
callq 0x312d0
movq -0x150(%rbp), %rsi
leaq -0xe0(%rbp), %rdi
callq 0x31210
jmp 0x2e974
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x2e9c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
jmp 0x2e9ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x110(%rbp)
movl %eax, -0x114(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x31310
leaq -0x100(%rbp), %rdi
callq 0x68a8
leaq -0x101(%rbp), %rdi
callq 0x64e0
jmp 0x2e9dd
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2db60
callq 0x8450
movsd -0x88(%rbp), %xmm3
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movaps %xmm0, %xmm4
movsd -0x70(%rbp), %xmm0
mulsd %xmm4, %xmm3
leaq -0x50(%rbp), %rdi
callq 0x30f40
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x30eb0
movq -0x28(%rbp), %rdi
callq 0x30f90
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm2
movsd 0x24040(%rip), %xmm1    # 0x52e68
divsd %xmm2, %xmm1
callq 0x6790
movaps %xmm0, %xmm1
movsd 0x24144(%rip), %xmm0    # 0x52f80
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x2412b(%rip), %xmm0    # 0x52f78
movsd %xmm0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31130
movq %rax, %rcx
movq -0x38(%rbp), %rax
movsd (%rcx), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2ee85
jp 0x2ee85
jmp 0x2ee9c
movq -0x38(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd (%rax), %xmm1
callq 0x31170
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd 0x23f77(%rip), %xmm0    # 0x52e60
ucomisd -0x18(%rbp), %xmm0
jbe 0x2efa4
cvtsi2sdl -0x1c(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x24050(%rip), %xmm0    # 0x52f68
callq 0x6790
movsd %xmm0, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x31130
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm2
movsd 0x23f14(%rip), %xmm1    # 0x52e68
divsd %xmm2, %xmm1
callq 0x6790
movq -0x38(%rbp), %rax
movaps %xmm0, %xmm1
movsd 0x24014(%rip), %xmm0    # 0x52f80
mulsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2ef8b
jp 0x2ef8b
jmp 0x2efa2
movq -0x38(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd (%rax), %xmm1
callq 0x31170
movsd %xmm0, -0x10(%rbp)
jmp 0x2efa4
movsd -0x10(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0xe, -0x18(%rbp)
jae 0x30ff2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20340
movsd (%rax), %xmm0
callq 0x8450
movsd %xmm0, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x31130
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x30fac
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35d10
movaps %xmm0, %xmm1
movsd 0x1d1d4(%rip), %xmm0    # 0x52e60
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x6810
movq -0x58(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
callq 0x35d30
movsd -0x60(%rbp), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
callq 0x6120
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x35da0
movq %rax, %rdx
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35d60
movq -0x58(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x35db0
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35df0
movq -0x58(%rbp), %rdi
callq 0x274c0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/Matrix.h
// Function: Eigen::Matrix<double, 4, 1, 0, 4, 1>::Matrix(double const&, double const&, double const&, double const&)
EIGEN_STRONG_INLINE Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w)
    {
      Base::_check_template_params();
      EIGEN_STATIC_ASSERT_VECTOR_SPECIFIC_SIZE(Matrix, 4)
      m_storage.data()[0] = x;
      m_storage.data()[1] = y;
      m_storage.data()[2] = z;
      m_storage.data()[3] = w;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x26b20
callq 0x26b50
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x27cb0
movsd -0x50(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x27cb0
movsd -0x48(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movsd %xmm0, 0x8(%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x27cb0
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movsd %xmm0, 0x10(%rax)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x27cb0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: istellartech[P]OpenTsiolkovsky/src/../lib/Eigen/src/Core/Swap.h
// Function: void Eigen::SwapWrapper<Eigen::Matrix<double, 2, 1, 0, 2, 1>>::copyPacket<Eigen::Matrix<double, 2, 1, 0, 2, 1>, 1, 1>(long, long, Eigen::DenseBase<Eigen::Matrix<double, 2, 1, 0, 2, 1>> const&)
void copyPacket(Index rowId, Index colId, const DenseBase<OtherDerived>& other)
    {
      OtherDerived& _other = other.const_cast_derived();
      eigen_internal_assert(rowId >= 0 && rowId < rows()
                        && colId >= 0 && colId < cols());
      Packet tmp = m_expression.template packet<StoreMode>(rowId, colId);
      m_expression.template writePacket<StoreMode>(rowId, colId,
        _other.template packet<LoadMode>(rowId, colId)
      );
      _other.template writePacket<LoadMode>(rowId, colId, tmp);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
callq 0x39cb0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3a120
movq -0x70(%rbp), %rax
movapd %xmm0, -0x40(%rbp)
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3a120
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movapd %xmm0, -0x50(%rbp)
leaq -0x50(%rbp), %rcx
callq 0x3a180
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x3a180
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3eac0
testb $0x1, %al
jne 0x3ea23
jmp 0x3ea68
movq -0x20(%rbp), %rsi
addq $0x30, %rsi
leaq -0x18(%rbp), %rdi
callq 0x3eaf0
jmp 0x3ea36
movq -0x20(%rbp), %rax
movb $0x1, 0x10(%rax)
leaq -0x18(%rbp), %rdi
callq 0x3eb30
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x6260
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x6750
jmp 0x3ea66
jmp 0x3ea68
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x67f0
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
callq 0x67f0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x3eb70
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x3eba0
movq -0x20(%rbp), %rdi
callq 0x3ebd0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8700
nopw %cs:(%rax,%rax)