LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::debug_print()
void Folder::debug_print()
{
	cerr << "Folder contains " << msgs.size() << " messages" << endl;
	int ctr = 1;
	for (auto m : msgs) {
		cerr << "Message " << ctr++ << ":\n\t" << m->contents << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0xe1e5(%rip), %rdi      # 0x10ff0
leaq 0x8280(%rip), %rsi      # 0xb092
callq 0x2120
movq -0x38(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x3590
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
leaq 0x8269(%rip), %rsi      # 0xb0a3
callq 0x2120
movq %rax, %rdi
movq 0xe177(%rip), %rsi      # 0x10fc0
callq 0x2160
movq -0x38(%rbp), %rax
movl $0x1, -0xc(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3200
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3230
testb $0x1, %al
jne 0x2e8a
jmp 0x2ef5
leaq -0x20(%rbp), %rdi
callq 0x3260
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq 0xe14f(%rip), %rdi      # 0x10ff0
leaq 0x8205(%rip), %rsi      # 0xb0ad
callq 0x2120
movq %rax, %rdi
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
callq 0x21e0
movq %rax, %rdi
leaq 0x81f3(%rip), %rsi      # 0xb0bd
callq 0x2120
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x2110
movq %rax, %rdi
movq 0xe0db(%rip), %rsi      # 0x10fc0
callq 0x2160
leaq -0x20(%rbp), %rdi
callq 0x32e0
jmp 0x2e77
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: evincarofautumn[P]protodata/./write.h
// Function: void write_float<double>(Interpreter::State const&, double const&, Stream&)
void write_float
  (const Interpreter::State& state, const T& input, Stream& output) {
  switch (state.format) {
  case Term::INTEGER:
    throw std::runtime_error
      ("Float values cannot be written in integer format.");
  case Term::FLOAT:
    switch (state.width) {
    case 32:
      write_float_value<float>(state.endianness, input, output);
      break;
    case 64:
      write_float_value<double>(state.endianness, input, output);
      break;
    default:
      IMPOSSIBLE("invalid float bit width");
    }
    break;
  case Term::UNICODE:
    throw std::runtime_error
      ("Float values cannot be written in Unicode format.");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x50(%rbp)
testl %eax, %eax
je 0x6b8f
jmp 0x6b74
movl -0x50(%rbp), %eax
subl $0x1, %eax
je 0x6be2
jmp 0x6b7e
movl -0x50(%rbp), %eax
subl $0x2, %eax
je 0x6cc7
jmp 0x6d17
movl $0x10, %edi
callq 0x4150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x135a7(%rip), %rsi     # 0x1a151
callq 0x40f0
jmp 0x6bb1
movq -0x58(%rbp), %rdi
movq 0x1f434(%rip), %rsi     # 0x25ff0
movq 0x1f3d5(%rip), %rdx     # 0x25f98
callq 0x44b0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4200
jmp 0x6d1d
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
subl $0x20, %eax
je 0x6bfc
jmp 0x6bf2
movl -0x5c(%rbp), %eax
subl $0x40, %eax
je 0x6c15
jmp 0x6c2e
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb3a0
jmp 0x6cc5
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb3e0
jmp 0x6cc5
movb $0x1, -0x49(%rbp)
movl $0x10, %edi
callq 0x4150
movq %rax, -0x68(%rbp)
leaq 0x1349a(%rip), %rsi     # 0x1a0e1
leaq 0x134a6(%rip), %rdx     # 0x1a0f4
leaq 0x1394e(%rip), %rcx     # 0x1a5a3
leaq -0x48(%rbp), %rdi
callq 0x8fc0
jmp 0x6c60
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4450
jmp 0x6c6f
movq -0x68(%rbp), %rdi
movb $0x0, -0x49(%rbp)
movq 0x1f342(%rip), %rsi     # 0x25fc0
movq 0x1f323(%rip), %rdx     # 0x25fa8
callq 0x44b0
jmp 0x6d26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x6cb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41a0
testb $0x1, -0x49(%rbp)
jne 0x6cba
jmp 0x6cc3
movq -0x68(%rbp), %rdi
callq 0x4200
jmp 0x6d1d
jmp 0x6d17
movl $0x10, %edi
callq 0x4150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq 0x134a1(%rip), %rsi     # 0x1a183
callq 0x40f0
jmp 0x6ce9
movq -0x70(%rbp), %rdi
movq 0x1f2fc(%rip), %rsi     # 0x25ff0
movq 0x1f29d(%rip), %rdx     # 0x25f98
callq 0x44b0
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x4200
jmp 0x6d1d
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44d0
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/./write.h
// Function: void write_integer_value<unsigned char, long>(Term::Endianness, long const&, Stream&)
void write_integer_value
  (const Term::Endianness endianness, const I& input, Stream& output) {
  typedef std::numeric_limits<decltype(input)> input_limits;
  typedef std::numeric_limits<O> type_limits;
  if (input < type_limits::min() || input > type_limits::max())
    throw std::runtime_error
      (join("Value exceeds range of ", type_name<O>::value, " integer."));
  const O buffer(input);
  endian_copy(buffer, endianness, output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
callq 0x94a0
movb %al, %cl
movq -0x50(%rbp), %rax
movzbl %cl, %ecx
cmpq %rcx, %rax
jl 0x8543
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x94b0
movb %al, %cl
movq -0x58(%rbp), %rax
movzbl %cl, %ecx
cmpq %rcx, %rax
jle 0x85d7
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x4150
movq %rax, -0x60(%rbp)
leaq 0x11bca(%rip), %rsi     # 0x1a126
leaq 0x1dd6d(%rip), %rdx     # 0x262d0
leaq 0x11b52(%rip), %rcx     # 0x1a0bc
leaq -0x38(%rbp), %rdi
callq 0x94c0
jmp 0x8575
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4470
jmp 0x8584
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x1da5d(%rip), %rsi     # 0x25ff0
movq 0x1d9fe(%rip), %rdx     # 0x25f98
callq 0x44b0
jmp 0x8600
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x85c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41a0
testb $0x1, -0x45(%rbp)
jne 0x85cc
jmp 0x85d5
movq -0x60(%rbp), %rdi
callq 0x4200
jmp 0x85f7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb %al, -0x46(%rbp)
movl -0x4(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x46(%rbp), %rdi
callq 0x9570
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x44d0
// File: evincarofautumn[P]protodata/./write.h
// Function: void write_unicode_value<unsigned char, long>(Term::Endianness, long const&, Stream&, unsigned char* (*)(unsigned int, unsigned char*))
void write_unicode_value(const Term::Endianness endianness, const I& input,
  Stream& output, O* (*append)(uint32_t, O*)) {
  const uint32_t rune(input);
  std::array<O, sizeof(uint32_t) / sizeof(O)> buffer;
  const auto end(append(rune, &buffer[0]));
  for (auto i = &buffer[0]; i != end; ++i)
    endian_copy(*i, endianness, output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa690
movl -0x44(%rbp), %edi
movq %rax, %rsi
movq -0x40(%rbp), %rax
callq *%rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa690
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x90f5
movq -0x38(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x9570
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x90cd
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: evincarofautumn[P]protodata/./util.h
// Function: unsigned short* utf8::append16<unsigned short*>(unsigned int, unsigned short*)
u16_iterator append16(const uint32_t rune, u16_iterator result) {
    if (rune > 0xffff) {
      *result++ = static_cast<uint16_t>((rune >> 10) + internal::LEAD_OFFSET);
      *result++ = static_cast<uint16_t>
        ((rune & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
    } else {
      *result++ = static_cast<uint16_t>(rune);
    }
    return result;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xffff, -0x4(%rbp)     # imm = 0xFFFF
jbe 0x93c8
movl -0x4(%rbp), %eax
shrl $0xa, %eax
addl $0xd7c0, %eax           # imm = 0xD7C0
movw %ax, %cx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x10(%rbp)
movw %cx, (%rax)
movl -0x4(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0xdc00, %eax           # imm = 0xDC00
movw %ax, %cx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x10(%rbp)
movw %cx, (%rax)
jmp 0x93e0
movl -0x4(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x10(%rbp)
movw %cx, (%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/./write.h
// Function: void endian_copy<unsigned char>(unsigned char const&, Term::Endianness, Stream&)
void endian_copy
  (const T& value, const Term::Endianness endianness, Stream& output) {
  using namespace std;
  array<char, sizeof(T)> buffer;
  const auto begin = reinterpret_cast<const char*>(&value),
    end = begin + sizeof(T);
  copy(begin, end, buffer.begin());
  if (endianness != Term::NATIVE && endianness != platform_endianness())
    reverse(buffer.begin(), buffer.end());
  output.write(buffer.begin(), buffer.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x97a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x9760
cmpl $0x0, -0xc(%rbp)
je 0x95fc
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x97c0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
je 0x95fc
leaq -0x19(%rbp), %rdi
callq 0x97a0
movq %rax, -0x50(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x9820
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x97e0
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x97a0
movq %rax, -0x58(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x9820
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x9840
addq $0x60, %rsp
popq %rbp
retq
// File: evincarofautumn[P]protodata/Stream.cpp
// Function: Stream::~Stream()
Stream::~Stream() {
  const auto extra = buffer.size() % 8;
  if (extra != 0)
    for (int i = 0; i < (8 - extra); ++i)
      buffer.push_back(false);
  flush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
callq 0xb740
andq $0x7, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb48b
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movl $0x8, %ecx
subq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jae 0xb489
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movb $0x0, -0x15(%rbp)
leaq -0x15(%rbp), %rsi
callq 0xb760
jmp 0xb47c
jmp 0xb47e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb453
jmp 0xb48b
movq -0x20(%rbp), %rdi
callq 0xb4c0
jmp 0xb496
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xb790
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6f20
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/Stream.cpp
// Function: Stream::flush()
void Stream::flush() {
  while (buffer.size() >= 8) {
    uint8_t octet = 0;
    for (int i = 0; i < 8; ++i)
      octet |= *(buffer.begin() + i) << (7 - i);
    buffer.erase(buffer.begin(), buffer.begin() + 8);
    stream.put(octet);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0xb740
cmpq $0x8, %rax
jb 0xb5d0
movb $0x0, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xb54a
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0xb830
movq %rax, -0x20(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xb860
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb8a0
movzbl (%rax), %eax
movl $0x7, %ecx
subl -0x10(%rbp), %ecx
shll %cl, %eax
movl %eax, %ecx
movzbl -0x9(%rbp), %eax
orl %ecx, %eax
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb4f6
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0xb830
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb950
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
callq 0xb830
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x8, %esi
callq 0xb860
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb950
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xb8c0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
movsbl -0x9(%rbp), %esi
callq 0x4030
jmp 0xb4d4
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/Stream.cpp
// Function: Stream::write(char)
void Stream::write(const char raw) {
  const uint8_t octet = raw;
  if (buffer.empty()) {
    stream.put(octet);
  } else {
    for (int i = 7; i >= 0; --i)
      buffer.push_back(bool(octet & (1 << i)));
  }
  flush();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movb -0x9(%rbp), %al
movb %al, -0xa(%rbp)
addq $0x8, %rdi
callq 0xb7f0
testb $0x1, %al
jne 0xb60f
jmp 0xb621
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movsbl -0xa(%rbp), %esi
callq 0x4030
jmp 0xb669
movl $0x7, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0xb667
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movzbl -0xa(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0xb760
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb628
jmp 0xb669
movq -0x20(%rbp), %rdi
callq 0xb4c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: evincarofautumn[P]protodata/Term.cpp
// Function: Term::Term(Term::Type, void const*)
Term::Term(const Type type, const void* const source = 0) : type(type) {
  switch (type) {
  case NOOP:
    break;
  case PUSH:
  case POP:
    break;
  case WRITE_SIGNED:
    value.as_signed = *static_cast<const Signed*>(source);
    break;
  case WRITE_UNSIGNED:
    value.as_unsigned = *static_cast<const Unsigned*>(source);
    break;
  case WRITE_DOUBLE:
    value.as_double = *static_cast<const Double*>(source);
    break;
  default:
    IMPOSSIBLE("invalid Term type");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
movq %rax, -0x50(%rbp)
subq $0x5, %rax
ja 0xc8d9
movq -0x50(%rbp), %rax
leaq 0xd978(%rip), %rcx      # 0x1a200
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xc96d
jmp 0xc96d
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xc96d
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xc96d
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0xc96d
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x4150
movq %rax, -0x60(%rbp)
leaq 0xd7ef(%rip), %rsi      # 0x1a0e1
leaq 0xd91f(%rip), %rdx      # 0x1a218
leaq 0xdca3(%rip), %rcx      # 0x1a5a3
leaq -0x38(%rbp), %rdi
callq 0xca70
jmp 0xc90b
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4450
jmp 0xc91a
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x19697(%rip), %rsi     # 0x25fc0
movq 0x19678(%rip), %rdx     # 0x25fa8
callq 0x44b0
jmp 0xc97c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xc95a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41a0
testb $0x1, -0x45(%rbp)
jne 0xc962
jmp 0xc96b
movq -0x60(%rbp), %rdi
callq 0x4200
jmp 0xc973
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x44d0
nopl (%rax)
// File: evincarofautumn[P]protodata/main.cpp
// Function: report(std::exception const&, int)
void report(const std::exception& exception, int depth) {
  std::cerr << std::string(depth * 2, ' ') << exception.what() << '\n';
  try {
    ::rethrow_if_nested(exception);
  } catch (const std::exception& exception) {
    report(exception, depth + 1);
  } catch (...) {
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl %eax, %eax
cltq
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x44e0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x20, %edx
callq 0x10390
jmp 0xff7f
movq 0x16062(%rip), %rdi     # 0x25fe8
leaq -0x30(%rbp), %rsi
callq 0x4290
movq %rax, -0x68(%rbp)
jmp 0xff95
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x42b0
movq %rax, -0x70(%rbp)
jmp 0xffb4
movq -0x70(%rbp), %rdi
movl $0xa, %esi
callq 0x43b0
jmp 0xffc4
leaq -0x30(%rbp), %rdi
callq 0x41a0
leaq -0x31(%rbp), %rdi
callq 0x4320
movq -0x8(%rbp), %rdi
callq 0x10400
jmp 0xffe1
jmp 0x1004b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41a0
leaq -0x31(%rbp), %rdi
callq 0x4320
jmp 0x10076
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x10051
movq -0x40(%rbp), %rdi
callq 0x4110
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
incl %esi
callq 0xff40
jmp 0x10046
callq 0x4490
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4110
callq 0x4490
jmp 0x1004b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x4490
jmp 0x10074
jmp 0x10076
movq -0x40(%rbp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x6f20
nopw (%rax,%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: parse(std::istream&, Interpreter&)
void parse(std::istream& input, Interpreter& interpreter) {
  unsigned int line = 1;
  unsigned int column = 0;
  try {
    parse_internal(input, interpreter, line, column);
  } catch (...) {
    ::throw_with_nested(std::runtime_error
      (join("At line ", line, ", column ", column, ":")));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %rcx
callq 0x10d30
jmp 0x10c65
jmp 0x10cd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4110
leaq 0x9c2f(%rip), %rsi      # 0x1a8b2
leaq 0x9c31(%rip), %rcx      # 0x1a8bb
leaq 0x99b9(%rip), %r9       # 0x1a64a
leaq -0x58(%rbp), %rdi
leaq -0x14(%rbp), %rdx
leaq -0x18(%rbp), %r8
callq 0x13530
jmp 0x10ca4
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4470
jmp 0x10cb3
leaq -0x38(%rbp), %rdi
callq 0x101b0
jmp 0x10cbe
leaq -0x38(%rbp), %rdi
callq 0x4568
leaq -0x58(%rbp), %rdi
callq 0x41a0
callq 0x4490
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10d15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x10d0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4568
leaq -0x58(%rbp), %rdi
callq 0x41a0
callq 0x4490
jmp 0x10d1c
jmp 0x10d1e
movq -0x20(%rbp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x6f20
nop
// File: evincarofautumn[P]protodata/parse.cpp
// Function: bool (anonymous namespace)::accept_if<bool (*)(unsigned int), __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>>(bool (*)(unsigned int), __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>)
bool accept_if(P predicate, I& input, I end) {
  if (input == end)
    return false;
  if (predicate(*input)) {
    ++input;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x136b0
testb $0x1, %al
jne 0x12727
jmp 0x1272d
movb $0x0, -0x1(%rbp)
jmp 0x12762
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13c00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %edi
callq *%rax
testb $0x1, %al
jne 0x1274f
jmp 0x1275e
movq -0x20(%rbp), %rdi
callq 0x13c20
movb $0x1, -0x1(%rbp)
jmp 0x12762
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: bool (anonymous namespace)::transition<(anonymous namespace)::State, char32_t, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&>((anonymous namespace)::State&, (anonymous namespace)::State const&, char32_t&&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&)
bool transition(T& state, const T& target, Args&&... args) {
  if (accept(std::forward<Args>(args)...)) {
    state = target;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
callq 0x128e0
testb $0x1, %al
jne 0x127b0
jmp 0x127c2
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x127c6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: bool (anonymous namespace)::transition_if<(anonymous namespace)::State, bool (&)(unsigned int), __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&>((anonymous namespace)::State&, (anonymous namespace)::State const&, bool (&)(unsigned int), __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
bool transition_if(T& state, const T& target, Args&&... args) {
  if (accept_if(std::forward<Args>(args)...)) {
    state = target;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x12940
testb $0x1, %al
jne 0x128b1
jmp 0x128c3
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x128c7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: bool (anonymous namespace)::accept<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>>(unsigned int, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>)
bool accept(uint32_t rune, I& input, I end) {
  if (input == end)
    return false;
  if (*input == rune) {
    ++input;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x10(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x136b0
testb $0x1, %al
jne 0x12906
jmp 0x1290c
movb $0x0, -0x1(%rbp)
jmp 0x1292f
movq -0x20(%rbp), %rdi
callq 0x13c00
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1292b
movq -0x20(%rbp), %rdi
callq 0x13c20
movb $0x1, -0x1(%rbp)
jmp 0x1292f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: bool (anonymous namespace)::accept_if<bool (*)(unsigned int), __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(bool (*)(unsigned int), __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
bool accept_if(P predicate, I& input, I end, O output) {
  if (input == end)
    return false;
  if (predicate(*input)) {
    utf8::append(*input++, output);
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x136b0
testb $0x1, %al
jne 0x1296b
jmp 0x12971
movb $0x0, -0x1(%rbp)
jmp 0x129cc
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13c00
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl (%rcx), %edi
callq *%rax
testb $0x1, %al
jne 0x12993
jmp 0x129c8
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x14000
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x13c00
movl (%rax), %edi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x13910
movq %rax, -0x40(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x129cc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: (anonymous namespace)::parse_width(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned long parse_width(const std::string& token) {
  const auto begin = token.c_str() + 1;
  char* boundary;
  const auto width = std::strtoul(begin, &boundary, 10);
  if (boundary != token.c_str() + token.size())
    throw std::runtime_error
      (join("Invalid unsigned type: '", token, "'."));
  if (width == 0 || width > 64)
    throw std::runtime_error
      (join("Unsupported width of unsigned type: '", token, "'."));
  return width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4120
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x40d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4120
movq %rax, -0x88(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41e0
movq -0x88(%rbp), %rcx
movq %rax, %rdx
movq -0x80(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x12af4
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x4150
movq %rax, -0x90(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x7f2c(%rip), %rsi      # 0x1a99d
leaq 0x7b2a(%rip), %rcx      # 0x1a5a2
leaq -0x40(%rbp), %rdi
callq 0x14b20
jmp 0x12a83
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4470
jmp 0x12a95
movq -0x90(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
movq 0x13549(%rip), %rsi     # 0x25ff0
movq 0x134ea(%rip), %rdx     # 0x25f98
callq 0x44b0
jmp 0x12bb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12adb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x41a0
testb $0x1, -0x4d(%rbp)
jne 0x12ae3
jmp 0x12aef
movq -0x90(%rbp), %rdi
callq 0x4200
jmp 0x12bb0
cmpq $0x0, -0x20(%rbp)
je 0x12b06
cmpq $0x40, -0x20(%rbp)
jbe 0x12ba3
movb $0x1, -0x71(%rbp)
movl $0x10, %edi
callq 0x4150
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x7e90(%rip), %rsi      # 0x1a9b6
leaq 0x7a75(%rip), %rcx      # 0x1a5a2
leaq -0x70(%rbp), %rdi
callq 0x14c10
jmp 0x12b38
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4470
jmp 0x12b4a
movq -0x98(%rbp), %rdi
movb $0x0, -0x71(%rbp)
movq 0x13494(%rip), %rsi     # 0x25ff0
movq 0x13435(%rip), %rdx     # 0x25f98
callq 0x44b0
jmp 0x12bb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12b8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x41a0
testb $0x1, -0x71(%rbp)
jne 0x12b95
jmp 0x12ba1
movq -0x98(%rbp), %rdi
callq 0x4200
jmp 0x12bb0
movq -0x20(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x44d0
nopl (%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: (anonymous namespace)::write_double_term(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Term write_double_term(const std::string& token) {
  char* boundary;
  const auto value = std::strtod(token.c_str(), &boundary);
  if (boundary != token.c_str() + token.size())
    throw std::runtime_error
      (join("Invalid floating-point literal: \"", token, "\""));
  return Term::write(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x4210
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4120
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41e0
movq -0x68(%rbp), %rcx
movq %rax, %rdx
movq -0x60(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x12f2c
movb $0x1, -0x55(%rbp)
movl $0x10, %edi
callq 0x4150
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x7a7d(%rip), %rsi      # 0x1a935
leaq 0x7abf(%rip), %rcx      # 0x1a97e
leaq -0x48(%rbp), %rdi
callq 0x145b0
jmp 0x12eca
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0x12ed9
movq -0x70(%rbp), %rdi
movb $0x0, -0x55(%rbp)
movq 0x13108(%rip), %rsi     # 0x25ff0
movq 0x130a9(%rip), %rdx     # 0x25f98
callq 0x44b0
jmp 0x12f53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x12f19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41a0
testb $0x1, -0x55(%rbp)
jne 0x12f21
jmp 0x12f2a
movq -0x70(%rbp), %rdi
callq 0x4200
jmp 0x12f4a
movsd -0x28(%rbp), %xmm0
callq 0xca40
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x44d0
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/parse.cpp
// Function: bool (anonymous namespace)::accept<__gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(unsigned int, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>&, __gnu_cxx::__normal_iterator<unsigned int*, std::vector<unsigned int, std::allocator<unsigned int>>>, std::back_insert_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
bool accept(uint32_t rune, I& input, I end, O output) {
  if (input == end)
    return false;
  if (*input == rune) {
    utf8::append(*input, output);
    ++input;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %edi, -0x1c(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x136b0
testb $0x1, %al
jne 0x12f8a
jmp 0x12f90
movb $0x0, -0x1(%rbp)
jmp 0x12fd3
movq -0x28(%rbp), %rdi
callq 0x13c00
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x12fcf
movq -0x28(%rbp), %rdi
callq 0x13c00
movl (%rax), %edi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x13910
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13c20
movb $0x1, -0x1(%rbp)
jmp 0x12fd3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: evincarofautumn[P]protodata/vendor/utf8/checked.h
// Function: unsigned int utf8::next<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
uint32_t next(octet_iterator& it, octet_iterator end)
    {
        uint32_t cp = 0;
        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
        switch (err_code) {
            case internal::UTF8_OK :
                break;
            case internal::NOT_ENOUGH_ROOM :
                throw not_enough_room();
            case internal::INVALID_LEAD :
            case internal::INCOMPLETE_SEQUENCE :
            case internal::OVERLONG_SEQUENCE :
                throw invalid_utf8(*it);
            case internal::INVALID_CODE_POINT :
                throw invalid_code_point(cp);
        }
        return cp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x16b40
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x5, %rax
ja 0x16abd
movq -0x38(%rbp), %rax
leaq 0x3e75(%rip), %rcx      # 0x1a844
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x16abd
movl $0x8, %edi
callq 0x4150
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x4170
movq -0x40(%rbp), %rdi
callq 0x16ca0
movq -0x40(%rbp), %rdi
leaq 0xf2ea(%rip), %rsi      # 0x25cf8
leaq 0x2cb(%rip), %rdx       # 0x16ce0
callq 0x44b0
movl $0x10, %edi
callq 0x4150
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16d00
movq -0x48(%rbp), %rdi
movzbl (%rax), %esi
callq 0x16d20
jmp 0x16a43
movq -0x50(%rbp), %rdi
leaq 0xf2c2(%rip), %rsi      # 0x25d10
leaq 0x30b(%rip), %rdx       # 0x16d60
callq 0x44b0
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4200
jmp 0x16ac6
movl $0x10, %edi
callq 0x4150
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %esi
callq 0xa720
jmp 0x16a8f
movq -0x58(%rbp), %rdi
leaq 0xf046(%rip), %rsi      # 0x25ae0
leaq -0xc341(%rip), %rdx     # 0xa760
callq 0x44b0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4200
jmp 0x16ac6
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x44d0
nop
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: std::iterator_traits<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::difference_type utf8::internal::sequence_length<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
inline typename std::iterator_traits<octet_iterator>::difference_type
    sequence_length(octet_iterator lead_it)
    {
        uint8_t lead = utf8::internal::mask8(*lead_it);
        if (lead < 0x80)
            return 1;
        else if ((lead >> 5) == 0x6)
            return 2;
        else if ((lead >> 4) == 0xe)
            return 3;
        else if ((lead >> 3) == 0x1e)
            return 4;
        else
            return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x80, %eax
jge 0x16db5
movq $0x1, -0x8(%rbp)
jmp 0x16dff
movzbl -0x11(%rbp), %eax
sarl $0x5, %eax
cmpl $0x6, %eax
jne 0x16dcb
movq $0x2, -0x8(%rbp)
jmp 0x16dff
movzbl -0x11(%rbp), %eax
sarl $0x4, %eax
cmpl $0xe, %eax
jne 0x16de1
movq $0x3, -0x8(%rbp)
jmp 0x16dff
movzbl -0x11(%rbp), %eax
sarl $0x3, %eax
cmpl $0x1e, %eax
jne 0x16df7
movq $0x4, -0x8(%rbp)
jmp 0x16dff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_1<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int&)
utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end)
            return NOT_ENOUGH_ROOM;

        code_point = utf8::internal::mask8(*it);

        return UTF8_OK;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x17220
testb $0x1, %al
jne 0x16e37
jmp 0x16e40
movl $0x1, -0x4(%rbp)
jmp 0x16e61
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_2<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int&)
utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end) 
            return NOT_ENOUGH_ROOM;
        
        code_point = utf8::internal::mask8(*it);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);

        return UTF8_OK;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x17220
testb $0x1, %al
jne 0x16e97
jmp 0x16ea0
movl $0x1, -0x4(%rbp)
jmp 0x16f12
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x17260
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x16ee0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16f12
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x6, %eax
andl $0x7ff, %eax            # imm = 0x7FF
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16d00
movl -0x34(%rbp), %ecx
movsbl (%rax), %eax
andl $0x3f, %eax
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_3<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int&)
utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end)
            return NOT_ENOUGH_ROOM;
            
        code_point = utf8::internal::mask8(*it);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (*it) & 0x3f;

        return UTF8_OK;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x17220
testb $0x1, %al
jne 0x16f47
jmp 0x16f53
movl $0x1, -0x4(%rbp)
jmp 0x1700f
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x17260
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x16f93
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1700f
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0xc, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movl -0x44(%rbp), %ecx
movzbl %al, %eax
shll $0x6, %eax
andl $0xfff, %eax            # imm = 0xFFF
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x17260
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x16ff1
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1700f
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %ecx
andl $0x3f, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::get_sequence_4<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, unsigned int&)
utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
    {
        if (it == end)
           return NOT_ENOUGH_ROOM;

        code_point = utf8::internal::mask8(*it);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;

        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)

        code_point += (*it) & 0x3f;

        return UTF8_OK;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x17220
testb $0x1, %al
jne 0x17047
jmp 0x17053
movl $0x1, -0x4(%rbp)
jmp 0x1715d
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x17260
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x17096
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1715d
movq -0x20(%rbp), %rax
movl (%rax), %eax
shll $0x12, %eax
andl $0x1fffff, %eax         # imm = 0x1FFFFF
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movl -0x54(%rbp), %ecx
movzbl %al, %eax
shll $0xc, %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
addl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x17260
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x170f4
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1715d
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x17200
movzbl %al, %ecx
shll $0x6, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
callq 0x17260
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x1713f
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1715d
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %ecx
andl $0x3f, %ecx
movq -0x20(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: bool utf8::internal::is_overlong_sequence<long>(unsigned int, long)
inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
    {
        if (cp < 0x80) {
            if (length != 1) 
                return true;
        }
        else if (cp < 0x800) {
            if (length != 2) 
                return true;
        }
        else if (cp < 0x10000) {
            if (length != 3) 
                return true;
        }

        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0x17193
cmpq $0x1, -0x10(%rbp)
je 0x17191
movb $0x1, -0x1(%rbp)
jmp 0x171cb
jmp 0x171c7
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jae 0x171ab
cmpq $0x2, -0x10(%rbp)
je 0x171a9
movb $0x1, -0x1(%rbp)
jmp 0x171cb
jmp 0x171c5
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0x171c3
cmpq $0x3, -0x10(%rbp)
je 0x171c1
movb $0x1, -0x1(%rbp)
jmp 0x171cb
jmp 0x171c3
jmp 0x171c5
jmp 0x171c7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: evincarofautumn[P]protodata/vendor/utf8/core.h
// Function: utf8::internal::utf_error utf8::internal::increase_safely<__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, __gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
utf_error increase_safely(octet_iterator& it, octet_iterator end)
    {
        if (++it == end)
            return NOT_ENOUGH_ROOM;

        if (!utf8::internal::is_trail(*it))
            return INCOMPLETE_SEQUENCE;
        
        return UTF8_OK;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x171e0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x17220
testb $0x1, %al
jne 0x1728b
jmp 0x17294
movl $0x1, -0x4(%rbp)
jmp 0x172b9
movq -0x18(%rbp), %rdi
callq 0x16d00
movsbl (%rax), %edi
callq 0x172d0
testb $0x1, %al
jne 0x172b2
movl $0x3, -0x4(%rbp)
jmp 0x172b9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)