LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: root_end_element_handler(void*, char const*)
void root_end_element_handler(void* udata, const XML_Char* name) {
    user_data* data = (user_data*)udata;
    switch (data->state) {
        case State::ROOT:
            break;
        case State::IN_CONFIG:
            if (strcmp(name, "config") == 0) data->state = State::ROOT;
            break;
        case State::IN_SECTIONS:
            if (strcmp(name, "sections") == 0) data->state = State::IN_CONFIG;
            break;
        case State::IN_SECTION:
            if (strcmp(name, data->section.c_str()) == 0) data->state = State::IN_SECTIONS;
            break;
        case State::IN_GROUPS:
            if (strcmp(name, "groups") == 0) data->state = State::IN_SECTION;
            break;
        case State::IN_GROUP:
            if (strcmp(name, data->group.c_str()) == 0) data->state = State::IN_GROUPS;
            break;
        case State::IN_FIELDS:
            if (strcmp(name, "fields") == 0) data->state = State::IN_GROUP;
            break;
        case State::IN_FIELD:
            if (strcmp(name, data->field.c_str()) == 0) data->state = State::IN_FIELDS;
            break;
    }
}

// Assembly:
movl (%rdi), %eax
addl $-0x2, %eax
cmpl $0x6, %eax
ja 0x2662
pushq %rbx
movq %rdi, %rbx
leaq 0x1a81(%rip), %rcx      # 0x4020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1adf(%rip), %rax      # 0x408e
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x1
jmp 0x265e
movq 0x30(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x5
jmp 0x265e
movq 0x10(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x3
jmp 0x265e
leaq 0x1a9c(%rip), %rax      # 0x409e
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x4
jmp 0x265e
leaq 0x1a79(%rip), %rax      # 0x4095
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x2
jmp 0x265e
leaq 0x1a6f(%rip), %rax      # 0x40a5
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x6
jmp 0x265e
movq 0x50(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2220
testl %eax, %eax
jne 0x2661
pushq $0x7
popq %rax
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/magento-config.cpp
// Function: parse_module_config::operator()(char const*)
void operator()(const char* filename) {
        XML_SetUserData(parser.handle(), &data);
        XML_SetElementHandler(parser.handle(), root_start_element_handler, root_end_element_handler);
        XML_SetCharacterDataHandler(parser.handle(), character_data_handler);

        data.filename = filename;

        std::ifstream in{data.filename};
        if (in) parse_xml(parser, in, &data);
        else std::cerr << "Can't open " << data.filename << "\n";

        parser.reset();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rbx), %r14
movq %r14, %rsi
callq 0x2050
movq (%rbx), %rdi
leaq -0x4d3(%rip), %rsi      # 0x23dc
leaq -0x330(%rip), %rdx      # 0x2586
callq 0x2150
movq (%rbx), %rdi
leaq -0x262(%rip), %rsi      # 0x2663
callq 0x21b0
movq %r15, 0x10(%rbx)
movq %rsp, %r12
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2290
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x291e
movq 0x36fb(%rip), %rdi      # 0x5ff0
leaq 0x17c7(%rip), %rsi      # 0x40c3
callq 0x2160
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x17a2(%rip), %rsi      # 0x40b6
movq %rax, %rdi
callq 0x2160
jmp 0x292c
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x29f0
movq %rbx, %rdi
callq 0x2ad6
movq %rsp, %rdi
callq 0x2070
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/xml.hpp
// Function: void parse_xml<user_data>(xml_parser&, std::basic_ifstream<char, std::char_traits<char>>&, user_data*)
void parse_xml(xml_parser& parser, std::ifstream& in, T* data) {
    const int size = 1024;
    char buf[size];
    while (in) {
        in.read(buf, size);
        XML_Status ret = XML_Parse(parser.handle(), buf, in.gcount(), in ? 0 : 1);
        if (!ret) {
            XML_Error error = XML_GetErrorCode(parser.handle());
            int line = XML_GetCurrentLineNumber(parser.handle());
            std::cerr << data->filename << ":" << line << ": error: " << XML_ErrorString(error) << "\n";
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
jne 0x2ac5
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r12, %rsi
callq 0x21e0
movq (%r14), %rdi
movl 0x8(%r15), %edx
movq (%r15), %rax
movq -0x18(%rax), %rax
xorl %ecx, %ecx
testb $0x5, 0x20(%r15,%rax)
setne %cl
movq %r12, %rsi
callq 0x2280
testl %eax, %eax
jne 0x2a0b
movq (%r14), %rdi
callq 0x2200
movl %eax, %ebp
movq (%r14), %rdi
callq 0x20d0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x357d(%rip), %rdi      # 0x5ff0
callq 0x2160
leaq 0x1650(%rip), %rsi      # 0x40cf
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movl %r14d, %esi
callq 0x2250
leaq 0x1638(%rip), %rsi      # 0x40d1
movq %rax, %rdi
callq 0x2160
movq %rax, %rbx
movl %ebp, %edi
callq 0x2040
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2160
leaq 0x15f9(%rip), %rsi      # 0x40b6
movq %rax, %rdi
callq 0x2160
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: swap(Message&, Message&)
void swap(Message& lhs, Message& rhs)
{
	using std::swap;  // not strictly needed in this case, but good habit

	// remove pointers to each Message from their (original) respective Folders
	for (auto f : lhs.folders)
		f->remMsg(&lhs);
	for (auto f : rhs.folders)
		f->remMsg(&rhs);

	// swap the contents and Folder pointer sets
	swap(lhs.folders, rhs.folders);   // uses swap(set&, set&)
	swap(lhs.contents, rhs.contents); // swap(string&, string&)

	// add pointers to each Message to their (new) respective Folders
	for (auto f : lhs.folders)
		f->addMsg(&lhs);
	for (auto f : rhs.folders)
		f->addMsg(&rhs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %r15
leaq 0x28(%rdi), %r13
cmpq %r13, %r15
je 0x2396
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x2ac6
movq %r15, %rdi
callq 0x2160
movq %rax, %r15
jmp 0x2378
leaq 0x20(%r14), %rax
movq %rax, -0x30(%rbp)
movq 0x38(%rbx), %r12
movq %rbx, %r15
addq $0x28, %rbx
cmpq %rbx, %r12
je 0x23c8
movq 0x20(%r12), %rdi
movq %r15, %rsi
callq 0x2ac6
movq %r12, %rdi
callq 0x2160
movq %rax, %r12
jmp 0x23a9
movq %r15, %r12
leaq 0x20(%r15), %rsi
movq -0x30(%rbp), %rdi
callq 0x3c3c
movq %r14, %rdi
movq %r15, %rsi
callq 0x20e0
movq 0x38(%r14), %r15
cmpq %r13, %r15
je 0x2405
movq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x2ae4
movq %r15, %rdi
callq 0x2160
movq %rax, %r15
jmp 0x23e7
movq 0x38(%r12), %r14
cmpq %rbx, %r14
je 0x2428
movq 0x20(%r14), %rdi
movq %r12, %rsi
callq 0x2ae4
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
jmp 0x240a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::move_Messages(Folder*)
void Folder::move_Messages(Folder* f)
{
	msgs = std::move(f->msgs); // move the set from f to this Folder
	f->msgs.clear(); // ensure that destroying f is harmless
	for (auto m : msgs) {  // for each Message in this Folder
		m->remFldr(f);     // remove the pointer to the old Folder
		m->addFldr(this);  // insert pointer to this Folder
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2d42
movq %rbx, %rdi
callq 0x2d98
movq 0x18(%r14), %r15
leaq 0x8(%r14), %r13
cmpq %r13, %r15
je 0x24f3
movq 0x20(%r15), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2b02
movq %r12, %rdi
movq %r14, %rsi
callq 0x2b24
movq %r15, %rdi
callq 0x2160
movq %rax, %r15
jmp 0x24c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::operator=(Folder&&)
Folder& Folder::operator=(Folder&& f)
{
	if (this != &f) {
		remove_from_Msgs();  // remove this Folder from the current msgs
		move_Messages(&f);   // make each Message point to this Folder
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2527
movq %rsi, %r14
movq %rbx, %rdi
callq 0x2530
movq %rbx, %rdi
movq %r14, %rsi
callq 0x249e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::move_Folders(Message*)
void Message::move_Folders(Message* m)
{
	folders = std::move(m->folders); // uses set move assignment
	for (auto f : folders) {  // for each Folder
		f->remMsg(m);    // remove the old Message from the Folder
		f->addMsg(this); // add this Message to that Folder
	}
	m->folders.clear();  // ensure that destroying m is harmless
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
addq $0x20, %rsi
addq $0x20, %rdi
movq %rsi, -0x30(%rbp)
callq 0x3452
movq 0x38(%r15), %r12
leaq 0x28(%r15), %r14
cmpq %r14, %r12
je 0x2628
movq 0x20(%r12), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2ac6
movq %r13, %rdi
movq %r15, %rsi
callq 0x2ae4
movq %r12, %rdi
callq 0x2160
movq %rax, %r12
jmp 0x25fb
movq -0x30(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34a8
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::operator=(Message&&)
Message& Message::operator=(Message&& rhs)
{
	if (this != &rhs) {       // direct check for self-assignment
		remove_from_Folders();
		contents = std::move(rhs.contents); // move assignment
		move_Folders(&rhs); // reset the Folders to point to this Message
	}
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2728
movq %rsi, %r14
movq %rbx, %rdi
callq 0x2730
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25ce
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Message::operator=(Message const&)
Message& Message::operator=(const Message& rhs)
{
	// handle self-assignment by removing pointers before inserting them
	remove_from_Folders();    // update existing Folders
	contents = rhs.contents;  // copy message contents from rhs
	folders = rhs.folders;    // copy Folder pointers from rhs
	add_to_Folders(rhs);      // add this Message to those Folders
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2730
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20b0
leaq 0x20(%rbx), %rsi
leaq 0x20(%r14), %rdi
callq 0x31c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26b6
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH13_CopyControl/examples/Folder.cc
// Function: Folder::operator=(Folder const&)
Folder& Folder::operator=(const Folder& f)
{
	remove_from_Msgs();  // remove this folder from each Message in msgs
	msgs = f.msgs;       // copy the set of Messages from f
	add_to_Messages(f);  // add this folder to each Message in msgs
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2530
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3686
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27e6
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x563c(%rip), %rdi      # 0x7ff0
leaq 0x26d7(%rip), %rsi      # 0x5092
callq 0x2120
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0x20d0
leaq 0x26d0(%rip), %rsi      # 0x50a3
movq %rax, %rdi
callq 0x2120
movq %rax, %rdi
callq 0x2090
movq 0x18(%rbx), %r15
addq $0x8, %rbx
pushq $0x1
popq %r14
cmpq %rbx, %r15
je 0x2a4c
movq 0x20(%r15), %r12
movq 0x55f1(%rip), %rdi      # 0x7ff0
leaq 0x26a7(%rip), %rsi      # 0x50ad
callq 0x2120
leal 0x1(%r14), %r13d
movq %rax, %rdi
movl %r14d, %esi
callq 0x21d0
movq %rax, %rdi
leaq 0x2699(%rip), %rsi      # 0x50bd
callq 0x2120
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x2160
movq %rax, %r15
movl %r13d, %r14d
jmp 0x29ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl 0xc(%rdi), %eax
cmpl $0x1, %eax
je 0x4889
cmpl $0x2, %eax
je 0x48b5
testl %eax, %eax
je 0x48d1
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl (%rdi), %eax
cmpl $0x40, %eax
je 0x48a5
cmpl $0x20, %eax
jne 0x4901
movl 0x4(%rdi), %edi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6122
movl 0x4(%rdi), %edi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x6139
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x6954(%rip), %rsi      # 0xb21b
movq %rax, %rdi
callq 0x30d0
jmp 0x48eb
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x6906(%rip), %rsi      # 0xb1e9
movq %rax, %rdi
callq 0x30d0
movq 0xd6fe(%rip), %rsi      # 0x11ff0
movq 0xd697(%rip), %rdx      # 0x11f90
movq %rbx, %rdi
callq 0x3390
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x6866(%rip), %rsi      # 0xb179
leaq 0x6872(%rip), %rdx      # 0xb18c
leaq 0x6d1a(%rip), %rcx      # 0xb63b
movq %rsp, %rdi
callq 0x5420
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3320
xorl %ebp, %ebp
movq 0xd678(%rip), %rsi      # 0x11fb8
movq 0xd659(%rip), %rdx      # 0x11fa0
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rsp, %rdi
callq 0x3110
testb %bpl, %bpl
jne 0x4968
jmp 0x4970
jmp 0x4965
jmp 0x4965
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/evincarofautumn[P]protodata/./write.h
// Function: void write_integer_value<unsigned int, 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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq (%rsi), %rcx
movq %rcx, %rsi
shrq $0x20, %rsi
jne 0x507b
movl %edi, %eax
movq %rsp, %rdi
movl %ecx, (%rdi)
movl %eax, %esi
callq 0x585b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x6131(%rip), %rsi      # 0xb1be
leaq 0xd19c(%rip), %rdx      # 0x12230
leaq 0x60b9(%rip), %rcx      # 0xb154
movq %rsp, %rdi
callq 0x5681
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3350
xorl %ebp, %ebp
movq 0xcf36(%rip), %rsi      # 0x11ff0
movq 0xcecf(%rip), %rdx      # 0x11f90
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rsp, %rdi
callq 0x3110
testb %bpl, %bpl
jne 0x50de
jmp 0x50e6
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
movl (%rsi), %edi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq *%rcx
movq %rax, %r15
cmpq %r15, %r14
je 0x54c2
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x56f1
incq %r14
jmp 0x54ab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/evincarofautumn[P]protodata/vendor/utf8/checked.h
// Function: unsigned char* utf8::append<unsigned char*>(unsigned int, unsigned char*)
octet_iterator append(uint32_t cp, octet_iterator result)
    {
        if (!utf8::internal::is_code_point_valid(cp))
            throw invalid_code_point(cp);

        if (cp < 0x80)                        // one octet
            *(result++) = static_cast<uint8_t>(cp);
        else if (cp < 0x800) {                // two octets
            *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
        }
        else if (cp < 0x10000) {              // three octets
            *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
        }
        else {                                // four octets
            *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
            *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
        }
        return result;
    }

// Assembly:
pushq %rbx
movl %edi, %ebx
cmpl $0x10ffff, %edi         # imm = 0x10FFFF
ja 0x5575
movl %ebx, %eax
andl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x5575
cmpl $0x7f, %ebx
ja 0x54fa
movb %bl, (%rsi)
incq %rsi
jmp 0x5570
movl %ebx, %eax
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x551a
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x1(%rsi)
addq $0x2, %rsi
jmp 0x5570
cmpl $0xffff, %ebx           # imm = 0xFFFF
ja 0x5544
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %ebx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x2(%rsi)
addq $0x3, %rsi
jmp 0x5570
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsi)
movl %ebx, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %ebx, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x3(%rsi)
addq $0x4, %rsi
movq %rsi, %rax
popq %rbx
retq
pushq $0x10
popq %rdi
callq 0x3120
leaq 0xc5a4(%rip), %rcx      # 0x11b28
movq %rcx, (%rax)
movl %ebx, 0x8(%rax)
leaq 0xc56f(%rip), %rsi      # 0x11b00
movq 0xca30(%rip), %rdx      # 0x11fc8
movq %rax, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x10000, %edi          # imm = 0x10000
jb 0x5607
movl %edi, %ecx
shrl $0xa, %ecx
addl $0xffffd7c0, %ecx       # imm = 0xFFFFD7C0
andl $0x3ff, %edi            # imm = 0x3FF
orl $0xdc00, %edi           # imm = 0xDC00
leaq 0x4(%rsi), %rax
movw %di, 0x2(%rsi)
jmp 0x560d
leaq 0x2(%rsi), %rax
movl %edi, %ecx
movw %cx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movb (%rdi), %al
movb %al, 0xf(%rsp)
cmpl $0x2, %esi
jb 0x5713
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdi
callq 0x5804
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x57da
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movl 0x10(%rdi), %r12d
subl 0x8(%rdi), %r12d
andl $0x7, %r12d
je 0x6190
orq $-0x8, %r12
leaq 0x7(%rsp), %r15
testq %r12, %r12
je 0x6190
movb $0x0, 0x7(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x633c
incq %r12
jmp 0x6176
movq %r14, %rdi
callq 0x61b6
movq %rbx, %rdi
callq 0x6310
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x61ae
movq %rax, %rdi
callq 0x4978
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
pushq $0x7
popq %rbp
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
cmpq $0x8, %rax
jb 0x620f
xorl %eax, %eax
movl %ebp, %ecx
xorl %r15d, %r15d
cmpq $0x8, %rax
je 0x61f5
movzbl (%rsi,%rax), %edx
shll %cl, %edx
orb %dl, %r15b
incq %rax
decl %ecx
jmp 0x61df
leaq 0x8(%rsi), %rdx
movq %r14, %rdi
callq 0x630a
movq (%rbx), %rdi
movsbl %r15b, %esi
callq 0x3030
jmp 0x61c7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x6262
leaq 0x8(%rbx), %r14
movzbl %sil, %ebp
pushq $0x7
popq %r12
leaq 0xf(%rsp), %r15
testl %r12d, %r12d
js 0x626e
btl %r12d, %ebp
setb 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x633c
decl %r12d
jmp 0x6244
movq (%rbx), %rdi
movsbl %sil, %esi
callq 0x3030
movq %rbx, %rdi
callq 0x61b6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, (%rdi)
cmpl $0x5, %esi
ja 0x6548
movl %esi, %eax
leaq 0x4d74(%rip), %rcx      # 0xb298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
jmp 0x653f
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x4c1f(%rip), %rsi      # 0xb179
leaq 0x4d4f(%rip), %rdx      # 0xb2b0
leaq 0x50d3(%rip), %rcx      # 0xb63b
movq %rsp, %rdi
callq 0x65dd
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3320
xorl %ebp, %ebp
movq 0xba31(%rip), %rsi      # 0x11fb8
movq 0xba12(%rip), %rdx      # 0x11fa0
movq %rbx, %rdi
callq 0x3390
movq %rax, %r14
movq %rsp, %rdi
callq 0x3110
testb %bpl, %bpl
jne 0x65ab
jmp 0x65b3
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/evincarofautumn[P]protodata/main.cpp
// Function: main
int main(int argc, char** argv) try {
  using namespace std;
  auto parsed_arguments = parse_arguments(argc, argv);
  const auto inputs = move(get<0>(parsed_arguments));
  const auto output = move(get<1>(parsed_arguments));
  vector<Term> terms;
  Interpreter interpreter(*output);
  for (const auto& input : inputs) try {
    parse(*input.stream, interpreter);
  } catch (...) {
    ::throw_with_nested(runtime_error(join("In input ", input.name, ":")));
  }
} catch (const std::exception& exception) {
  report(exception);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x8(%rsp), %rdi
callq 0x668c
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, 0x28(%rsp)
movq 0x18(%rsp), %r15
movq %r15, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq %rsi, (%rsp)
andq $0x0, 0x8(%rsp)
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x3f0c
leaq 0x88(%rsp), %r14
leaq 0x4234(%rip), %r12      # 0xb6e2
leaq 0x68(%rsp), %r13
leaq 0x58(%rsp), %rbp
cmpq %r15, %rbx
je 0x7516
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x79a8
addq $0x10, %rbx
jmp 0x74b8
movq %rax, %rdi
callq 0x30f0
movq %r13, %rdi
leaq 0x41f7(%rip), %rsi      # 0xb6d8
movq %rbx, %rdx
movq %r12, %rcx
callq 0x7726
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3350
movq %rbp, %rdi
callq 0x76d5
movq %rbp, %rdi
callq 0x3408
movq %r13, %rdi
callq 0x3110
callq 0x3370
jmp 0x74c9
leaq 0x88(%rsp), %rdi
callq 0x7796
leaq 0x40(%rsp), %rdi
callq 0x77d8
movq %rsp, %rdi
callq 0x6d90
leaq 0x28(%rsp), %rdi
callq 0x6db2
leaq 0x8(%rsp), %rdi
callq 0x77ac
xorl %eax, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x7594
movq %rdx, %r14
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3408
jmp 0x757d
movq %rdx, %r14
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3110
jmp 0x758f
movq %rdx, %r14
movq %rax, %rbx
callq 0x3370
leaq 0x88(%rsp), %rdi
callq 0x7796
jmp 0x75a9
movq %rdx, %r14
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x77d8
movq %rsp, %rdi
callq 0x6d90
leaq 0x28(%rsp), %rdi
callq 0x6db2
leaq 0x8(%rsp), %rdi
callq 0x77ac
jmp 0x75d7
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x7604
movq %rbx, %rdi
callq 0x30f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x7614
callq 0x3370
pushq $0x1
popq %rax
jmp 0x754b
movq %rax, %rbx
callq 0x3370
movq %rbx, %rdi
callq 0x33b0
movq %rax, %rdi
callq 0x4978
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
pushq $0x20
popq %rdx
callq 0x3290
movq 0xa9a5(%rip), %rdi      # 0x11fe8
movq %rsp, %rsi
callq 0x31f0
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x3210
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x32a0
movq %rsp, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x77c2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rdi
callq 0x30f0
cmpl $0x2, %r14d
jne 0x76a4
incl %ebx
movq %rax, %rdi
movl %ebx, %esi
callq 0x7614
callq 0x3370
jmp 0x767d
movq %rax, %rbx
callq 0x3370
jmp 0x76cd
movq %rax, %rdi
callq 0x4978
movq %rax, %rbx
jmp 0x76cd
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
leaq 0xc(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x8(%rsp), %rcx
andl $0x0, (%rcx)
callq 0x7a66
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x30f0
leaq 0x3e50(%rip), %rsi      # 0xb82a
leaq 0x3e52(%rip), %rcx      # 0xb833
leaq 0x3cfa(%rip), %r9       # 0xb6e2
leaq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %r8
callq 0x8c9b
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3350
leaq 0x10(%rsp), %rdi
callq 0x76d5
leaq 0x10(%rsp), %rdi
callq 0x3408
leaq 0x20(%rsp), %rdi
callq 0x3110
callq 0x3370
jmp 0x79c5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3408
jmp 0x7a42
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3110
jmp 0x7a51
movq %rax, %rbx
callq 0x3370
movq %rbx, %rdi
callq 0x33b0
movq %rax, %rdi
callq 0x4978
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq (%rsi), %rcx
cmpq %rdx, %rcx
je 0x8830
movq %rsi, %r14
movq %rdi, %rax
movl (%rcx), %edi
callq *%rax
testb %al, %al
je 0x8830
movq (%r14), %rax
leaq 0x4(%rax), %rcx
movq %rcx, (%r14)
movl (%rax), %edi
movq %rbx, %rsi
callq 0x8d6d
movb $0x1, %al
jmp 0x8832
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq (%rdi), %rdi
incq %rdi
leaq 0x28(%rsp), %rbx
pushq $0xa
popq %rdx
movq %rbx, %rsi
callq 0x30b0
movq (%r14), %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, (%rbx)
jne 0x887a
leaq -0x41(%rax), %rcx
cmpq $-0x41, %rcx
jbe 0x88ca
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x3089(%rip), %rsi      # 0xb915
leaq 0x2da7(%rip), %rcx      # 0xb63a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x92df
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3350
xorl %ebp, %ebp
movq 0x9737(%rip), %rsi      # 0x11ff0
movq 0x96d0(%rip), %rdx      # 0x11f90
movq %rbx, %rdi
callq 0x3390
jmp 0x8918
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x3052(%rip), %rsi      # 0xb92e
leaq 0x2d57(%rip), %rcx      # 0xb63a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x936a
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3350
xorl %ebp, %ebp
movq 0x96e7(%rip), %rsi      # 0x11ff0
movq 0x9680(%rip), %rdx      # 0x11f90
movq %rbx, %rdi
callq 0x3390
jmp 0x891c
jmp 0x8930
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3110
testb %bpl, %bpl
jne 0x8933
jmp 0x893b
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/evincarofautumn[P]protodata/parse.cpp
// Function: (anonymous namespace)::write_integer_term(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
Term write_integer_term(const std::string& token, int base) {
  const bool has_sign = token[0] == '-' || token[0] == '+';
  char* boundary;
  const auto begin = token.c_str(), end = begin + token.size();
  if (has_sign) {
    Term::Signed value = std::strtoll(begin, &boundary, base);
    if (boundary != end)
      throw std::runtime_error(join("Invalid base-", base,
        " signed integer literal: \"", token, "\""));
    return Term::write(value);
  } else {
    Term::Unsigned value = std::strtoull(begin, &boundary, base);
    if (boundary != end)
      throw std::runtime_error(join("Invalid base-", base,
        " unsigned integer literal: \"", token, "\""));
    return Term::write(value);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %edx
movq %rdi, %r14
movl %esi, 0xc(%rsp)
movq (%rdi), %rdi
movb (%rdi), %al
cmpb $0x2d, %al
jne 0x8968
movq 0x8(%r14), %r15
addq %rdi, %r15
jmp 0x8973
movq 0x8(%r14), %r15
addq %rdi, %r15
cmpb $0x2b, %al
jne 0x8997
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x3060
cmpq %r15, (%rbx)
jne 0x89bb
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x65cc
leaq 0x10(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
cmpq %r15, (%rbx)
jne 0x8a17
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x65c4
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x2f02(%rip), %rsi      # 0xb8cf
leaq 0x2f09(%rip), %rcx      # 0xb8dd
leaq 0x2f1b(%rip), %r9       # 0xb8f6
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %r8
callq 0x9049
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3350
xorl %ebp, %ebp
movq 0x95ea(%rip), %rsi      # 0x11ff0
movq 0x9583(%rip), %rdx      # 0x11f90
movq %rbx, %rdi
callq 0x3390
jmp 0x8a71
pushq $0x10
popq %rdi
callq 0x3120
movq %rax, %rbx
leaq 0x2ea6(%rip), %rsi      # 0xb8cf
leaq 0x2ec8(%rip), %rcx      # 0xb8f8
leaq 0x2ebf(%rip), %r9       # 0xb8f6
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %r8
callq 0x90f1
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3350
xorl %ebp, %ebp
movq 0x958e(%rip), %rsi      # 0x11ff0
movq 0x9527(%rip), %rdx      # 0x11f90
movq %rbx, %rdi
callq 0x3390
jmp 0x8a75
jmp 0x8a89
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x3110
testb %bpl, %bpl
jne 0x8a8c
jmp 0x8a94
movq %rax, %r14
movq %rbx, %rdi
callq 0x3180
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
callq 0x9a9d
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
jb 0x9a30
cmpl $0x5, %eax
je 0x9a53
cmpl $0x1, %eax
je 0x9a75
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
pushq $0x10
popq %rdi
callq 0x3120
movq (%rbx), %rcx
movb (%rcx), %cl
leaq 0x8314(%rip), %rdx      # 0x11d58
movq %rdx, (%rax)
movb %cl, 0x8(%rax)
leaq 0x82b7(%rip), %rsi      # 0x11d08
jmp 0x9a8e
pushq $0x10
popq %rdi
callq 0x3120
movl 0xc(%rsp), %ecx
leaq 0x80c2(%rip), %rdx      # 0x11b28
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
leaq 0x808d(%rip), %rsi      # 0x11b00
jmp 0x9a8e
pushq $0x8
popq %rdi
callq 0x3120
leaq 0x82ac(%rip), %rcx      # 0x11d30
movq %rcx, (%rax)
leaq 0x8262(%rip), %rsi      # 0x11cf0
movq 0x8533(%rip), %rdx      # 0x11fc8
movq %rax, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O2/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:
movzbl (%rdi), %ecx
testb %cl, %cl
js 0x9b97
pushq $0x1
jmp 0x9bb5
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x9ba7
pushq $0x2
jmp 0x9bb5
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0x9bb7
pushq $0x3
popq %rax
retq
andl $-0x8, %ecx
xorl %eax, %eax
cmpl $0xf0, %ecx
sete %al
shll $0x2, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpl $0x7f, %edi
ja 0x9d25
movb $0x1, %al
cmpq $0x1, %rsi
jne 0x9d24
xorl %eax, %eax
retq
cmpl $0x7ff, %edi            # imm = 0x7FF
ja 0x9d37
movb $0x1, %al
cmpq $0x2, %rsi
je 0x9d22
jmp 0x9d24
cmpl $0x10000, %edi          # imm = 0x10000
setb %cl
cmpq $0x3, %rsi
setne %dl
movb $0x1, %al
testb %dl, %cl
je 0x9d22
jmp 0x9d24
nop
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/threads/part1/Hello2.cpp
// Function: main
int main(){
    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([](){
            std::cout << "Hello from thread " << std::this_thread::get_id() << std::endl;
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
vxorps %xmm0, %xmm0, %xmm0
andq $0x0, 0x10(%rbx)
vmovaps %xmm0, (%rbx)
pushq $0x5
popq %rbp
pushq $0x10
popq %r14
leaq 0x2aee(%rip), %r13      # 0x3d88
leaq 0x8(%rsp), %r15
movq %rsp, %r12
subl $0x1, %ebp
jb 0x12ed
andq $0x0, 0x8(%rsp)
movq %r14, %rdi
callq 0x1100
movq %r13, (%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x12d8
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1424
movq %r15, %rdi
callq 0x13a2
jmp 0x12a2
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x130a
movq %rbx, %rdi
callq 0x1120
addq $0x8, %rbx
jmp 0x12f7
leaq 0x10(%rsp), %rdi
callq 0x13b0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1327
movq %rax, %rbx
jmp 0x134d
movq (%rsp), %rdi
movq %rax, %rbx
testq %rdi, %rdi
je 0x134d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x134d
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x13a2
leaq 0x10(%rsp), %rdi
callq 0x13b0
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline sink error(std::string message) {
    return sink(sink::action,
        [m = std::move(message)](const char*) -> bool {
            throw user_option_error(m);
        });
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2eba
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::usage_error(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void usage_error(const char* argv0, const std::string& usage_str, const std::string& parse_err, const std::string& prefix = "Usage: ") {
    const char* basename = std::strrchr(argv0, '/');
    basename = basename? basename+1: argv0;

    std::cerr << basename << ": " << parse_err << "\n";
    std::cerr << prefix << basename << " " << usage_str << "\n";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
pushq $0x2f
popq %rsi
callq 0x2170
leaq 0x1(%rax), %r15
testq %rax, %rax
cmoveq %r13, %r15
movq 0x722a(%rip), %r13      # 0x9ff0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x331d(%rip), %rsi      # 0x60f5
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq %r12, %rsi
callq 0x2130
leaq 0x32dd(%rip), %r12      # 0x60cf
movq %rax, %rdi
movq %r12, %rsi
callq 0x2140
movq %r13, %rdi
movq %r14, %rsi
callq 0x2130
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x32dc(%rip), %rsi      # 0x60f6
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq %rax, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: void to::option::init_<char const (&) [5], std::function<int (int)>>(to::option_flag, char const (&) [5], std::function<int (int)>&&)
void init_(enum option_flag f, Rest&&... rest) {
        is_flag      |= f & flag;
        is_ephemeral |= f & ephemeral;
        is_single    |= f & single;
        is_mandatory |= f & mandatory;
        is_exit      |= f & exit;
        is_stop      |= f & stop;
        is_lax       |= f & lax;
        init_(std::forward<Rest>(rest)...);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl %esi, %eax
andb $0x1, %al
orb %al, 0x68(%rdi)
movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pand 0x2a74(%rip), %xmm0     # 0x6020
movd 0x69(%rdi), %xmm1
pxor %xmm2, %xmm2
punpcklbw %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3],xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
por %xmm0, %xmm1
pcmpgtd %xmm2, %xmm1
packssdw %xmm1, %xmm1
packsswb %xmm1, %xmm1
pand 0x2a5b(%rip), %xmm1     # 0x6030
movd %xmm1, 0x69(%rdi)
movl %esi, %eax
andl $0x20, %eax
movzbl 0x6d(%rdi), %edi
orl %eax, %edi
setne 0x6d(%rbx)
movq %rcx, %r14
andl $0x40, %esi
movzbl 0x6e(%rbx), %eax
orl %esi, %eax
setne 0x6e(%rbx)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x36ec
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3670
leaq 0x8(%rsp), %rdi
callq 0x2090
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::saved_options::as_arglist() const
arglist as_arglist() const {
        arglist A;

        for (auto& a: *this) A.arg_data.push_back(const_cast<char*>(a.c_str()));
        A.arg_data.push_back(nullptr);
        A.argv = A.arg_data.data();
        A.argc = A.arg_data.size()-1;
        return A;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x3dcf
movq (%r12), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x48b8
addq $0x20, %r12
jmp 0x3db0
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x48b8
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rax, 0x8(%r14)
subq %rax, %rcx
shrq $0x3, %rcx
decl %ecx
movl %ecx, (%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3e0b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5992
movq %r14, %rdi
callq 0x2220