LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: bfwrite(bool*, int, _IO_FILE*)
void bfwrite(bool *ar,int mx,FILE *fp){ //ビット列arをmx個書き込む
    int ps = 0;
    unsigned char a;
    while(ps<mx){
        a = ar[ps]*128;
        if(ps+1<mx){a += ar[ps+1]*64;}
        if(ps+2<mx){a += ar[ps+2]*32;}
        if(ps+3<mx){a += ar[ps+3]*16;}
        if(ps+4<mx){a += ar[ps+4]*8;}
        if(ps+5<mx){a += ar[ps+5]*4;}
        if(ps+6<mx){a += ar[ps+6]*2;}
        if(ps+7<mx){a += ar[ps+7]*1;}
        fwrite(&a, sizeof(unsigned char),1,fp);
        ps+=8;
    }
}

// Assembly:
testl %esi, %esi
jle 0x20e0
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
movl $0x3, %r12d
movb -0x3(%r14,%r12), %al
shlb $0x7, %al
leaq -0x2(%r12), %rcx
cmpq %r15, %rcx
jae 0x2050
movb -0x2(%r14,%r12), %cl
shlb $0x6, %cl
orb %cl, %al
leaq -0x1(%r12), %rcx
cmpq %r15, %rcx
jae 0x2064
movb -0x1(%r14,%r12), %cl
shlb $0x5, %cl
addb %cl, %al
cmpq %r15, %r12
jae 0x2072
movb (%r14,%r12), %cl
shlb $0x4, %cl
addb %cl, %al
leaq 0x1(%r12), %rcx
cmpq %r15, %rcx
jae 0x2086
movb 0x1(%r14,%r12), %cl
shlb $0x3, %cl
addb %cl, %al
leaq 0x2(%r12), %rcx
cmpq %r15, %rcx
jae 0x209a
movb 0x2(%r14,%r12), %cl
shlb $0x2, %cl
addb %cl, %al
leaq 0x3(%r12), %rcx
cmpq %r15, %rcx
jae 0x20ad
movb 0x3(%r14,%r12), %cl
addb %cl, %cl
addb %cl, %al
leaq 0x4(%r12), %rcx
cmpq %r15, %rcx
jae 0x20bc
addb 0x4(%r14,%r12), %al
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1110
addq $0x8, %r12
leal -0x3(%r12), %eax
cmpl %ebp, %eax
jl 0x2034
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TooruAkagi[P]GCIS_Index/gcis_uni_build.cpp
// Function: shelp()
int shelp(){
    printf("--Simple Usage------------------\n");
    printf("\nRead 'index' and make 'codeindex'. \n");
    printf("This file needs for locating in idx_uni. \n");
    printf("Make sure that running 'gcis' and make file 'index' first before running 'gcis_uni'. \n");
    printf(": ./gcis_uni_build \n");
    printf("\nYou can set the name of inputfile by using option -i. \n");
    printf(": ./gcis_uni_build -i <inputfile>\n");
    printf("\nYou can set the name of outputfile by using option -o. \n");
    printf(": ./gcis_uni_build -o <outputfile>\n");
    printf("\n");
    printf("\n");
    return 0;
}

// Assembly:
pushq %rax
leaq 0xe09(%rip), %rdi       # 0x3125
callq 0x1160
leaq 0xe1e(%rip), %rdi       # 0x3146
callq 0x1160
leaq 0xe37(%rip), %rdi       # 0x316b
callq 0x1160
leaq 0xe55(%rip), %rdi       # 0x3195
callq 0x1160
leaq 0xe9f(%rip), %rdi       # 0x31eb
callq 0x1160
leaq 0xea7(%rip), %rdi       # 0x31ff
callq 0x1160
leaq 0xed3(%rip), %rdi       # 0x3237
callq 0x1160
leaq 0xee9(%rip), %rdi       # 0x3259
callq 0x1160
leaq 0xf16(%rip), %rdi       # 0x3292
callq 0x1160
movl $0xa, %edi
callq 0x1140
movl $0xa, %edi
callq 0x1140
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x278f
pushq %rbx
movq %rdi, %rbx
leaq 0x196b(%rip), %rcx      # 0x4020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x19c9(%rip), %rax      # 0x408e
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x1, %eax
jmp 0x278c
movq 0x30(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x5, %eax
jmp 0x278c
movq 0x10(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x3, %eax
jmp 0x278c
leaq 0x197a(%rip), %rax      # 0x409e
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x4, %eax
jmp 0x278c
leaq 0x1954(%rip), %rax      # 0x4095
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x2, %eax
jmp 0x278c
leaq 0x1947(%rip), %rax      # 0x40a5
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x6, %eax
jmp 0x278c
movq 0x50(%rbx), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2210
testl %eax, %eax
jne 0x278e
movl $0x7, %eax
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x773(%rip), %rsi      # 0x243c
leaq -0x51a(%rip), %rdx      # 0x269c
callq 0x2160
movq (%rbx), %rdi
leaq -0x435(%rip), %rsi      # 0x2790
callq 0x21c0
movq %r15, 0x10(%rbx)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x22b0
movq (%r12), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsp,%rax)
je 0x2c30
movq 0x33f9(%rip), %r14      # 0x5ff0
leaq 0x14c5(%rip), %rsi      # 0x40c3
movl $0xb, %edx
movq %r14, %rdi
callq 0x21b0
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x2c40
movq %r15, %rdi
callq 0x20b0
movq 0x33cd(%rip), %rdi      # 0x5ff0
movq %r15, %rsi
movq %rax, %rdx
callq 0x21b0
jmp 0x2c58
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d16
jmp 0x2c70
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2250
movq 0x3391(%rip), %rdi      # 0x5ff0
leaq 0x1450(%rip), %rsi      # 0x40b6
movl $0x1, %edx
callq 0x21b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x21a0
movq %rsp, %rdi
callq 0x2060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdx, 0x8(%rsp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
jne 0x2e92
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq 0x32a0(%rip), %r12      # 0x5ff0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f0
movq (%r15), %rdi
movl 0x8(%r14), %edx
movq (%r14), %rax
movq -0x18(%rax), %rax
xorl %ecx, %ecx
testb $0x5, 0x20(%r14,%rax)
setne %cl
movq %rbx, %rsi
callq 0x22a0
testl %eax, %eax
jne 0x2e7f
movl %eax, %ebp
movq %r12, %rbx
movq (%r15), %rdi
callq 0x2200
movl %eax, 0x4(%rsp)
movq (%r15), %rdi
callq 0x20d0
movq %rax, %r13
movq 0x8(%rsp), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x2dce
movq %r12, %rdi
callq 0x20b0
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, %r12
movq %rax, %rdx
callq 0x21b0
jmp 0x2de8
movq %rbx, %r12
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2250
movl $0x1, %edx
movq %r12, %rdi
leaq 0x12d8(%rip), %rsi      # 0x40cf
callq 0x21b0
movq %r12, %rdi
movl %r13d, %esi
callq 0x2260
movq %rax, %r13
movl $0x9, %edx
movq %rax, %rdi
leaq 0x12b8(%rip), %rsi      # 0x40d1
callq 0x21b0
movl 0x4(%rsp), %edi
callq 0x2040
testq %rax, %rax
je 0x2e47
movq %rax, %rbx
movq %rax, %rdi
callq 0x20b0
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21b0
jmp 0x2e62
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x2250
leaq 0x10(%rsp), %rbx
movl $0x1, %edx
movq %r13, %rdi
leaq 0x1240(%rip), %rsi      # 0x40b6
callq 0x21b0
testl %ebp, %ebp
je 0x2e92
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x2d50
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %r15
leaq 0x28(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq %rax, %r15
je 0x23e7
leaq -0x30(%rbp), %r12
movq 0x20(%r15), %r13
movq %rbx, -0x30(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x3d44
movq %r13, %rdi
movq %rax, %rsi
callq 0x3dc6
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
cmpq -0x38(%rbp), %rax
jne 0x23b8
movq %rbx, -0x50(%rbp)
leaq 0x20(%rbx), %rax
movq %rax, -0x48(%rbp)
leaq 0x20(%r14), %rax
movq %rax, -0x40(%rbp)
movq 0x38(%r14), %r13
leaq 0x28(%r14), %rbx
cmpq %rbx, %r13
je 0x243a
leaq -0x30(%rbp), %r15
movq 0x20(%r13), %r12
movq %r14, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d44
movq %r12, %rdi
movq %rax, %rsi
callq 0x3dc6
movq %r13, %rdi
callq 0x2170
movq %rax, %r13
cmpq %rbx, %rax
jne 0x240c
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3e4c
movq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x20e0
movq 0x38(%r12), %r15
cmpq -0x38(%rbp), %r15
movq %r14, %r13
je 0x2489
leaq -0x30(%rbp), %r14
movq 0x20(%r15), %rdi
movq %r12, -0x30(%rbp)
movq %r14, %rsi
callq 0x2f96
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
cmpq -0x38(%rbp), %rax
jne 0x2468
movq 0x38(%r13), %r14
cmpq %rbx, %r14
je 0x24b6
leaq -0x30(%rbp), %r15
movq 0x20(%r14), %rdi
movq %r13, -0x30(%rbp)
movq %r15, %rsi
callq 0x2f96
movq %r14, %rdi
callq 0x2170
movq %rax, %r14
cmpq %rbx, %rax
jne 0x2496
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2ec0
movq %rbx, -0x38(%rbp)
movq %rbx, %rdi
callq 0x3120
movq 0x18(%r14), %r15
leaq 0x8(%r14), %rbx
cmpq %rbx, %r15
je 0x25e0
leaq -0x30(%rbp), %r12
movq 0x20(%r15), %r13
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x20, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3c3c
movq %r13, %rdi
movq %rax, %rsi
callq 0x3cbe
movq %r14, -0x30(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x3158
movq %r15, %rdi
callq 0x2170
movq %rax, %r15
cmpq %rbx, %rax
jne 0x259b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2626
movq %rsi, %r14
cmpq $0x0, 0x28(%rbx)
je 0x261b
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rdi
movq %rbx, %rsi
callq 0x2b8e
jmp 0x2602
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2562
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %r15
movq %rsi, -0x40(%rbp)
addq $0x20, %rsi
addq $0x20, %rdi
movq %rsi, -0x38(%rbp)
callq 0x2f32
movq 0x38(%r15), %r12
leaq 0x28(%r15), %r14
cmpq %r14, %r12
je 0x27d0
leaq -0x30(%rbp), %r13
movq 0x20(%r12), %rbx
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3d44
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3dc6
movq %r15, -0x30(%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2f96
movq %r12, %rdi
callq 0x2170
movq %rax, %r12
cmpq %r14, %rax
jne 0x278e
movq -0x38(%rbp), %rdi
callq 0x3726
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2934
movq %rsi, %r14
movq %rbx, %rdi
callq 0x293c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2754
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x293c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2090
leaq 0x20(%rbx), %rsi
leaq 0x20(%r14), %rdi
callq 0x3486
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28b0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x2b31
movq 0x18(%rbx), %rax
movq 0x20(%rax), %rdi
movq %rbx, %rsi
callq 0x2b8e
cmpq $0x0, 0x28(%rbx)
jne 0x2b1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3902
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a2a
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq 0x631a(%rip), %r14      # 0x8ff0
leaq 0x33d1(%rip), %rsi      # 0x60ae
movl $0x10, %edx
movq %r14, %rdi
callq 0x2160
movq 0x28(%r15), %rsi
movq %r14, %rdi
callq 0x20b0
movq %rax, %r14
leaq 0x33bf(%rip), %rsi      # 0x60bf
movl $0x9, %edx
movq %rax, %rdi
callq 0x2160
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq 0x18(%r15), %r14
addq $0x8, %r15
cmpq %r15, %r14
je 0x2de7
movl $0x1, %r12d
movq 0x20(%r14), %rbx
movl $0x8, %edx
movq 0x6295(%rip), %r13      # 0x8ff0
movq %r13, %rdi
leaq 0x3364(%rip), %rsi      # 0x60c9
callq 0x2160
leal 0x1(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r13, %rdi
movl %r12d, %esi
callq 0x21c0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
leaq 0x334a(%rip), %rsi      # 0x60d9
callq 0x2160
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r12, %rdi
callq 0x2160
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2170
movq %rax, %r14
movl -0x2c(%rbp), %eax
movl %eax, %r12d
cmpq %r15, %r14
jne 0x2d4b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5550
cmpl $0x2, %eax
je 0x558f
testl %eax, %eax
jne 0x5586
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6ca3(%rip), %rsi      # 0xc1e9
movq %rax, %rdi
callq 0x30c0
jmp 0x55ab
movl (%rdi), %eax
cmpl $0x40, %eax
je 0x5571
cmpl $0x20, %eax
jne 0x55c1
cvtsd2ss (%rsi), %xmm0
movl 0x4(%rdi), %esi
movq %rsp, %rdi
movss %xmm0, (%rdi)
callq 0x67ed
jmp 0x5586
movl 0x4(%rdi), %eax
movsd (%rsi), %xmm0
movq %rsp, %rdi
movsd %xmm0, (%rdi)
movl %eax, %esi
callq 0x6842
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6c78(%rip), %rsi      # 0xc21b
movq %rax, %rdi
callq 0x30c0
movq 0xca3e(%rip), %rsi      # 0x11ff0
movq 0xc9cf(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6ba4(%rip), %rsi      # 0xc179
leaq 0x6bb0(%rip), %rdx      # 0xc18c
leaq 0x7058(%rip), %rcx      # 0xc63b
movq %rsp, %rdi
callq 0x6124
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e0
xorl %ebp, %ebp
movq 0xc9b6(%rip), %rsi      # 0x11fb8
movq 0xc997(%rip), %rdx      # 0x11fa0
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5637
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x5637
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0x5643
jmp 0x564b
jmp 0x5640
movq %rax, %r14
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/evincarofautumn[P]protodata/./write.h
// Function: void write_integer_value<unsigned short, 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
cmpq $0x10000, %rcx          # imm = 0x10000
jae 0x5c77
movl %edi, %eax
movq %rsp, %rdi
movw %cx, (%rdi)
movl %eax, %esi
callq 0x64cd
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x6533(%rip), %rsi      # 0xc1be
leaq 0xc586(%rip), %rdx      # 0x12218
leaq 0x64bb(%rip), %rcx      # 0xc154
movq %rsp, %rdi
callq 0x631d
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0xc338(%rip), %rsi      # 0x11ff0
movq 0xc2c9(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ced
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x5ced
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x5cfa
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/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 0x625e
movl %ebx, %eax
andl $0xfffff800, %eax       # imm = 0xFFFFF800
cmpl $0xd800, %eax           # imm = 0xD800
je 0x625e
cmpl $0x7f, %ebx
ja 0x61e3
movb %bl, (%rsi)
incq %rsi
jmp 0x6259
movl %ebx, %eax
cmpl $0x7ff, %ebx            # imm = 0x7FF
ja 0x6203
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %bl
orb $-0x80, %bl
movb %bl, 0x1(%rsi)
addq $0x2, %rsi
jmp 0x6259
cmpl $0xffff, %ebx           # imm = 0xFFFF
ja 0x622d
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 0x6259
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
movl $0x10, %edi
callq 0x3100
leaq 0xb8b1(%rip), %rcx      # 0x11b20
movq %rcx, (%rax)
movl %ebx, 0x8(%rax)
leaq 0xb87c(%rip), %rsi      # 0x11af8
movq 0xbd45(%rip), %rdx      # 0x11fc8
movq %rax, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/evincarofautumn[P]protodata/./write.h
// Function: void endian_copy<unsigned int>(unsigned int 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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl (%rdi), %eax
movl %eax, 0x4(%rsp)
cmpl $0x2, %esi
jb 0x653c
leaq 0x7(%rsp), %rax
xorl %ecx, %ecx
movb 0x4(%rsp,%rcx), %dl
movb (%rax), %sil
movb %sil, 0x4(%rsp,%rcx)
movb %dl, (%rax)
incq %rcx
decq %rax
cmpq $0x2, %rcx
jne 0x6522
xorl %r14d, %r14d
movsbl 0x4(%rsp,%r14), %esi
incq %r14
movq %rbx, %rdi
callq 0x6e82
cmpq $0x4, %r14
jne 0x653f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
leaq 0x8(%rdi), %r14
movl 0x10(%rdi), %r12d
subl 0x8(%rdi), %r12d
andl $0x7, %r12d
je 0x6db7
orq $-0x8, %r12
leaq 0x7(%rsp), %r15
movb $0x0, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f7c
incq %r12
jne 0x6da2
movq %rbx, %rdi
callq 0x6dea
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6dd3
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x3210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6de1
movq %rax, %rdi
callq 0x5653
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6eca
leaq 0x8(%rbx), %r14
movzbl %sil, %ebp
movl $0x7, %r12d
leaq 0xf(%rsp), %r15
btl %r12d, %ebp
setb 0xf(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f7c
addl $-0x1, %r12d
jb 0x6eae
jmp 0x6ed6
movq (%rbx), %rdi
movsbl %sil, %esi
callq 0x3030
movq %rbx, %rdi
callq 0x6dea
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7108
movl %esi, %eax
leaq 0x51b4(%rip), %rcx      # 0xc298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
jmp 0x70ff
movsd (%rdx), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x505d(%rip), %rsi      # 0xc179
leaq 0x518d(%rip), %rdx      # 0xc2b0
leaq 0x5511(%rip), %rcx      # 0xc63b
movq %rsp, %rdi
callq 0x71bf
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x32e0
xorl %ebp, %ebp
movq 0xae6f(%rip), %rsi      # 0x11fb8
movq 0xae50(%rip), %rdx      # 0x11fa0
movq %rbx, %rdi
callq 0x3360
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x717e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x717e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x718b
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xe8, %rsp
movq %rsi, %rdx
movl %edi, %esi
leaq 0x58(%rsp), %rdi
callq 0x7290
leaq 0x60(%rsp), %rbx
movq -0x8(%rbx), %rsi
movq (%rbx), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rsi, 0x8(%rsp)
movq %rax, -0x8(%rbx)
leaq 0x78(%rsp), %rdi
callq 0x491c
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r13
cmpq %r13, %r14
je 0x8361
leaq 0x78(%rsp), %r15
leaq 0x28(%rsp), %rbp
leaq 0x48(%rsp), %r12
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x886c
addq $0x10, %r14
cmpq %r13, %r14
jne 0x82eb
jmp 0x8361
movq %rax, %rdi
callq 0x30e0
movq %rbp, %rdi
leaq 0x43c4(%rip), %rsi      # 0xc6d8
movq %r14, %rdx
leaq 0x43c4(%rip), %rcx      # 0xc6e2
callq 0x8656
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3310
movq %r12, %rdi
callq 0x85d4
movq %r12, %rdi
callq 0x33e8
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x835a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3210
callq 0x3330
jmp 0x82f7
leaq 0x98(%rsp), %rdi
callq 0x565e
leaq 0x78(%rsp), %rdi
callq 0x6d7c
leaq 0x8(%rsp), %rdi
callq 0x7a62
leaq 0x10(%rsp), %rdi
callq 0x7a88
movq %rbx, %rdi
callq 0x7a88
leaq 0x58(%rsp), %rdi
callq 0x7a62
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
jmp 0x83fb
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x33e8
jmp 0x83d2
movq %rdx, %r15
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x83f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x83f6
movq %rdx, %r15
movq %rax, %r14
callq 0x3330
leaq 0x98(%rsp), %rdi
callq 0x565e
leaq 0x78(%rsp), %rdi
callq 0x6d7c
jmp 0x841a
movq %rdx, %r15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x7a62
leaq 0x10(%rsp), %rdi
callq 0x7a88
movq %rbx, %rdi
callq 0x7a88
leaq 0x58(%rsp), %rdi
callq 0x7a62
jmp 0x8448
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x8477
movq %r14, %rdi
callq 0x30e0
movq %rax, %rdi
xorl %esi, %esi
callq 0x8487
callq 0x3330
movl $0x1, %eax
jmp 0x83a0
movq %rax, %r14
callq 0x3330
movq %r14, %rdi
callq 0x3380
movq %rax, %rdi
callq 0x5653
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %eax
movslq %eax, %rsi
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x10(%rsp), %rdi
movl $0x20, %edx
callq 0x3280
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x9b20(%rip), %rdi      # 0x11fe8
callq 0x3270
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %rax, %rax
je 0x84f9
movq %rax, %r12
movq %rax, %rdi
callq 0x30f0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3270
jmp 0x8513
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x3350
leaq 0xf(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x3270
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x853f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0x9a8a(%rip), %rsi      # 0x11fd0
leaq 0x96eb(%rip), %rdx      # 0x11c38
movq %r14, %rdi
movq $-0x2, %rcx
callq 0x3260
testq %rax, %rax
je 0x8569
movq %rax, %rdi
callq 0x8826
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rax, %rdi
callq 0x30e0
cmpl $0x2, %r14d
jne 0x8594
incl %ebx
movq %rax, %rdi
movl %ebx, %esi
callq 0x8487
callq 0x3330
jmp 0x8569
movq %rax, %rbx
callq 0x3330
jmp 0x85cc
movq %rax, %rdi
callq 0x5653
movq %rax, %rbx
jmp 0x85cc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x85cc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rcx)
callq 0x894f
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x30e0
leaq 0x3f75(%rip), %rsi      # 0xc816
leaq 0x3f77(%rip), %rcx      # 0xc81f
leaq 0x3e33(%rip), %r9       # 0xc6e2
leaq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %r8
callq 0x9e07
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3310
leaq 0x10(%rsp), %rdi
callq 0x85d4
leaq 0x10(%rsp), %rdi
callq 0x33e8
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8901
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3210
callq 0x3330
jmp 0x888c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x33e8
jmp 0x891a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x893a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x893a
movq %rax, %rbx
callq 0x3330
movq %rbx, %rdi
callq 0x3380
movq %rax, %rdi
callq 0x5653
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rbx, %rsi
movl $0xa, %edx
callq 0x3090
movq (%r14), %rcx
addq 0x8(%r14), %rcx
cmpq %rcx, (%rbx)
jne 0x9a85
leaq -0x41(%rax), %rcx
cmpq $-0x41, %rcx
jbe 0x9ad7
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x2e68(%rip), %rsi      # 0xc901
leaq 0x2b9a(%rip), %rcx      # 0xc63a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xa6aa
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x852a(%rip), %rsi      # 0x11ff0
movq 0x84bb(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x9b27
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x2e2f(%rip), %rsi      # 0xc91a
leaq 0x2b48(%rip), %rcx      # 0xc63a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xa795
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x84d8(%rip), %rsi      # 0x11ff0
movq 0x8469(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x9b2b
jmp 0x9b4b
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b51
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x9b51
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9b5e
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O1/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
movzbl (%rdi), %eax
movq 0x8(%r14), %r15
addq %rdi, %r15
cmpl $0x2d, %eax
je 0x9b90
cmpl $0x2b, %eax
jne 0x9bb4
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x3060
cmpq %r15, (%rbx)
jne 0x9bd8
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x71aa
leaq 0x30(%rsp), %rbx
movq %rbx, %rsi
callq 0x32a0
cmpq %r15, (%rbx)
jne 0x9c36
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x71a0
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x2ccf(%rip), %rsi      # 0xc8bb
leaq 0x2cd6(%rip), %rcx      # 0xc8c9
leaq 0x2ce8(%rip), %r9       # 0xc8e2
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %r8
callq 0xa2b0
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x83cb(%rip), %rsi      # 0x11ff0
movq 0x835c(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x9c92
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x2c71(%rip), %rsi      # 0xc8bb
leaq 0x2c93(%rip), %rcx      # 0xc8e4
leaq 0x2c8a(%rip), %r9       # 0xc8e2
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %r8
callq 0xa3b5
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3310
xorl %ebp, %ebp
movq 0x836d(%rip), %rsi      # 0x11ff0
movq 0x82fe(%rip), %rdx      # 0x11f88
movq %rbx, %rdi
callq 0x3360
jmp 0x9c96
jmp 0x9cb6
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cbc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x9cbc
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9cc9
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rdx)
callq 0xae65
leal -0x2(%rax), %ecx
cmpl $0x3, %ecx
jb 0xadf2
cmpl $0x5, %eax
je 0xae17
cmpl $0x1, %eax
je 0xae3b
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movl $0x10, %edi
callq 0x3100
movq (%rbx), %rcx
movb (%rcx), %cl
leaq 0x6f48(%rip), %rdx      # 0x11d50
movq %rdx, (%rax)
movb %cl, 0x8(%rax)
leaq 0x6eeb(%rip), %rsi      # 0x11d00
jmp 0xae56
movl $0x10, %edi
callq 0x3100
movl 0xc(%rsp), %ecx
leaq 0x6cf4(%rip), %rdx      # 0x11b20
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
leaq 0x6cbf(%rip), %rsi      # 0x11af8
jmp 0xae56
movl $0x8, %edi
callq 0x3100
leaq 0x6edc(%rip), %rcx      # 0x11d28
movq %rcx, (%rax)
leaq 0x6e92(%rip), %rsi      # 0x11ce8
movq 0x716b(%rip), %rdx      # 0x11fc8
movq %rax, %rdi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %rsp
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
vmovaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x5, %ebp
leaq 0x2acf(%rip), %r12      # 0x3d88
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq $0x0, 0x8(%rsp)
movl $0x10, %edi
callq 0x1100
movq %r12, (%rax)
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x10d0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x12f7
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1442
cmpq $0x0, 0x8(%rsp)
jne 0x1381
decl %ebp
jne 0x12c1
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x132b
movq %rbx, %rdi
callq 0x1130
addq $0x8, %rbx
jmp 0x1318
leaq 0x10(%rsp), %rdi
callq 0x140e
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x136c
jmp 0x136c
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x135a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0x136f
cmpq $0x0, 0x8(%rsp)
jne 0x1381
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x140e
movq %rbx, %rdi
callq 0x1140
callq 0x1040
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %r13, %r14
testq %r14, %r14
je 0x32e2
movq %r14, %rdi
callq 0x2090
movq 0x7d1b(%rip), %rdi      # 0xaff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x3300
movq 0x7d07(%rip), %rax      # 0xaff0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x21f0
movq 0x7ce9(%rip), %r13      # 0xaff0
leaq 0x3dab(%rip), %rsi      # 0x70b9
movl $0x2, %edx
movq %r13, %rdi
callq 0x2170
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x2170
leaq 0x3d60(%rip), %rsi      # 0x7093
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r13, %rdi
callq 0x2170
movq %rax, %r15
testq %r14, %r14
je 0x336f
movq %r14, %rdi
callq 0x2090
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2170
jmp 0x3389
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x21f0
leaq 0x3d2a(%rip), %rsi      # 0x70ba
movl $0x1, %edx
movq %r15, %rdi
callq 0x2170
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x2170
leaq 0x3ce0(%rip), %rsi      # 0x7093
movl $0x1, %edx
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl %esi, %eax
andl $0x2, %eax
movzbl 0x69(%rdi), %edi
orl %eax, %edi
setne 0x69(%rbx)
movl %esi, %eax
andl $0x4, %eax
movzbl 0x6a(%rbx), %edi
orl %eax, %edi
setne 0x6a(%rbx)
movl %esi, %eax
andl $0x8, %eax
movzbl 0x6b(%rbx), %edi
orl %eax, %edi
setne 0x6b(%rbx)
movl %esi, %eax
andl $0x10, %eax
movzbl 0x6c(%rbx), %edi
orl %eax, %edi
setne 0x6c(%rbx)
movl %esi, %eax
andl $0x20, %eax
movzbl 0x6d(%rbx), %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 0x3cce
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3c26
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3bf5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3c1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x2210
nop