LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/venGaza[P]starwars/src/DetentionBlock.cpp
// Function: DetentionBlock::getChoice[abi:cxx11]()
string DetentionBlock::getChoice() {
    if (!doorOpen) {
        cout << "Please select a choice (enter integer): ";
        int choice = getInteger();
        validate(choice, 1, 4);
        cout << endl;
        
        if (choice == 1) {
            return "north";
        } else if (choice == 2) {
            return "items";
        } else if (choice == 3){
            return "look";
        } else {
            doorOpen = true;
            return "open";
        }
    } else {
        cout << "Please select a choice (enter integer): ";
        int choice = getInteger();
        validate(choice, 1, 4);
        cout << endl;
        
        if (choice == 1) {
            return "north";
        } else if (choice == 2) {
            return "items";
        } else {
            return "look";
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x68(%rsi), %bpl
movq 0x69d9(%rip), %rdi      # 0xbfd0
leaq 0xc1c(%rip), %rsi       # 0x621a
callq 0x2150
testb %bpl, %bpl
je 0x5655
callq 0x50e8
leaq 0x10(%rsp), %r14
movl %eax, (%r14)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x3650
movq 0x69a6(%rip), %rdi      # 0xbfd0
callq 0x20b0
movl (%r14), %eax
cmpl $0x2, %eax
je 0x56a4
cmpl $0x1, %eax
jne 0x56ba
leaq 0xc00(%rip), %rsi       # 0x6243
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
jmp 0x5715
callq 0x50e8
leaq 0x14(%rsp), %r15
movl %eax, (%r15)
pushq $0x1
popq %rsi
pushq $0x4
popq %rdx
movq %r15, %rdi
callq 0x3650
movq 0x6959(%rip), %rdi      # 0xbfd0
callq 0x20b0
movl (%r15), %eax
cmpl $0x3, %eax
je 0x56e6
cmpl $0x2, %eax
je 0x56d0
cmpl $0x1, %eax
jne 0x56fc
leaq 0xbae(%rip), %rsi       # 0x6243
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
jmp 0x5715
leaq 0xba9(%rip), %rsi       # 0x6254
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
jmp 0x5715
leaq 0xb99(%rip), %rsi       # 0x625a
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
jmp 0x5715
leaq 0xb7d(%rip), %rsi       # 0x6254
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
jmp 0x5715
leaq 0xb6d(%rip), %rsi       # 0x625a
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
jmp 0x5715
movb $0x1, 0x68(%r14)
leaq 0x1527(%rip), %rsi      # 0x6c2f
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x2968
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x572f
jmp 0x572f
jmp 0x572f
jmp 0x572f
jmp 0x572f
jmp 0x572f
movq %rax, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/venGaza[P]starwars/src/KyloSpace.cpp
// Function: KyloSpace::KyloSpace()
KyloSpace::KyloSpace() {
    Space::roomName = "Command Center";
    Space::roomDescription= "The Command Center where all the nefarious bad guys tend to hang out. Oh look, Kylo Ren is here and he does not look happy to see you!";
    
    Space::top = nullptr;
    Space::bottom = new SnokeSpace;
    Space::bottom->setTop(this);
    Space::left = new LaunchBay;
    Space::left->setRight(this);
    Space::right = new SnokeSpace;
    Space::right->setLeft(this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x59f8
leaq 0x65ec(%rip), %rax      # 0xbd38
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x24bb(%rip), %rsi      # 0x7c15
callq 0x2250
leaq 0x28(%rbx), %rdi
leaq 0x25c9(%rip), %rsi      # 0x7d33
callq 0x2250
andq $0x0, 0x48(%rbx)
pushq $0x68
popq %rdi
callq 0x2160
movq %rax, %r15
movq %rax, %rdi
callq 0x2a3c
movq %r15, 0x50(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5af6
pushq $0x68
popq %rdi
callq 0x2160
movq %rax, %r15
movq %rax, %rdi
callq 0x2bb0
movq %r15, 0x60(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b08
pushq $0x68
popq %rdi
callq 0x2160
movq %rax, %r15
movq %rax, %rdi
callq 0x2a3c
movq %r15, 0x58(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5b02
popq %rbx
popq %r14
popq %r15
retq
jmp 0x57e4
jmp 0x57e4
movq %rax, %r14
pushq $0x68
popq %rsi
movq %r15, %rdi
callq 0x2170
jmp 0x57f7
movq %rax, %r14
movq %rbx, %rdi
callq 0x5a80
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/venGaza[P]starwars/src/KyloSpace.cpp
// Function: KyloSpace::KyloSpace(Space*, Space*, Space*, Space*)
KyloSpace::KyloSpace(Space* top, Space* bottom, Space* left, Space* right) {
    this->Space::top = top;
    this->Space::bottom = bottom;
    this->Space::left = left;
    this->Space::right = right;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x59f8
leaq 0x650c(%rip), %rax      # 0xbd38
movq %rax, (%r13)
movq %r12, 0x48(%r13)
movq %r15, 0x50(%r13)
movq %r14, 0x60(%r13)
movq %rbx, 0x58(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/venGaza[P]starwars/src/KyloSpace.cpp
// Function: KyloSpace::printChoices()
void KyloSpace::printChoices() {
    cout << "1) North - Startanium Door" << endl
    << "2) East - Mysterious Room" << endl
    << "3) West - Launch Bay" << endl
    << "4) Item Inventory " << endl
    << "5) Look around" << endl << endl;
}

// Assembly:
pushq %rax
movq 0x670a(%rip), %rdi      # 0xbfd0
leaq 0x24ed(%rip), %rsi      # 0x7dba
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x24f4(%rip), %rsi      # 0x7dd5
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x24f7(%rip), %rsi      # 0x7def
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x8e9(%rip), %rsi       # 0x61f8
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
leaq 0x8e5(%rip), %rsi       # 0x620b
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movq %rax, %rdi
popq %rax
jmp 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/venGaza[P]starwars/src/Space.cpp
// Function: Space::Space()
Space::Space() {
    Space::roomName = "";
    Space::roomDescription= "";
    
    Space::top = nullptr;
    Space::bottom = nullptr;
    Space::left = nullptr;
    Space::right = nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x6379(%rip), %rax      # 0xbd80
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x6f6(%rip), %rsi       # 0x6131
movq %rbx, %rdi
callq 0x2250
leaq 0x6e7(%rip), %rsi       # 0x6131
movq %r15, %rdi
callq 0x2250
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_finish_test_line_
static void
acutest_finish_test_line_(enum acutest_state_ state)
{
    if(acutest_tap_) {
        printf("%s %d - %s%s\n",
                (state == ACUTEST_STATE_SUCCESS || state == ACUTEST_STATE_SKIPPED) ? "ok" : "not ok",
                acutest_current_index_ + 1,
                acutest_current_test_->name,
                (state == ACUTEST_STATE_SKIPPED) ? " # SKIP" : "");

        if(state == ACUTEST_STATE_SUCCESS  &&  acutest_timer_) {
            printf("# Duration: ");
            acutest_timer_print_diff_();
            printf("\n");
        }
    } else {
        int color;
        const char* str;

        switch(state) {
            case ACUTEST_STATE_SUCCESS: color = ACUTEST_COLOR_GREEN_INTENSIVE_; str = "OK"; break;
            case ACUTEST_STATE_SKIPPED: color = ACUTEST_COLOR_YELLOW_INTENSIVE_; str = "SKIPPED"; break;
            case ACUTEST_STATE_FAILED:  /* Fall through. */
            default:                    color = ACUTEST_COLOR_RED_INTENSIVE_; str = "FAILED"; break;
        }

        printf("[ ");
        acutest_colored_printf_(color, "%s", str);
        printf(" ]");

        if(state == ACUTEST_STATE_SUCCESS  &&  acutest_timer_) {
            printf("  ");
            acutest_timer_print_diff_();
        }

        printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpb $0x1, 0x8c1d(%rip)      # 0xb494
jne 0x28dc
cmpl $0x2, %ebx
leaq 0x5028(%rip), %rax      # 0x78ab
leaq 0x501d(%rip), %rsi      # 0x78a7
cmoveq %rax, %rsi
leaq 0x5019(%rip), %rcx      # 0x78ae
leaq 0x51f3(%rip), %r8       # 0x7a8f
cmoveq %rcx, %r8
testl %ebx, %ebx
movl 0x8c08(%rip), %edx      # 0xb4b0
movq 0x8a99(%rip), %rcx      # 0xb348
movq (%rcx), %rcx
cmoveq %rax, %rsi
incl %edx
leaq 0x4fda(%rip), %rdi      # 0x7899
xorl %eax, %eax
callq 0x2180
testl %ebx, %ebx
jne 0x28f0
cmpl $0x0, 0x8be3(%rip)      # 0xb4b4
je 0x28f0
leaq 0x4fdc(%rip), %rdi      # 0x78b6
jmp 0x294d
testl %ebx, %ebx
je 0x28f5
cmpl $0x2, %ebx
jne 0x2900
leaq 0x4fda(%rip), %r14      # 0x78c6
pushq $0xd
jmp 0x2909
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4fc7(%rip), %r14      # 0x78c3
pushq $0xc
jmp 0x2909
leaq 0x4fc7(%rip), %r14      # 0x78ce
pushq $0xb
popq %rbp
leaq 0x4fc4(%rip), %rdi      # 0x78d5
xorl %eax, %eax
callq 0x2180
leaq 0x5008(%rip), %rsi      # 0x7927
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x29de
leaq 0x4fa6(%rip), %rdi      # 0x78d8
xorl %eax, %eax
callq 0x2180
testl %ebx, %ebx
jne 0x2959
cmpl $0x0, 0x8b70(%rip)      # 0xb4b4
je 0x2959
leaq 0x4834(%rip), %rdi      # 0x7181
xorl %eax, %eax
callq 0x2180
callq 0x4d68
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_line_indent_
static void
acutest_line_indent_(int level)
{
    static const char spaces[] = "                ";
    int n = level * 2;

    if(acutest_tap_  &&  n > 0) {
        n--;
        printf("#");
    }

    while(n > 16) {
        printf("%s", spaces);
        n -= 16;
    }
    printf("%.*s", n, spaces);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
addl %edi, %ebx
cmpb $0x1, 0x8b1f(%rip)      # 0xb494
jne 0x2981
decl %ebx
pushq $0x23
popq %rdi
callq 0x2050
leaq 0x4f9f(%rip), %r14      # 0x7927
leaq 0x46e1(%rip), %r15      # 0x7070
cmpl $0x11, %ebx
jl 0x29a6
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
addl $-0x10, %ebx
jmp 0x298f
leaq 0x4f39(%rip), %rdi      # 0x78e6
leaq 0x46bc(%rip), %rdx      # 0x7070
movl %ebx, %esi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_case_
acutest_case_(const char* fmt, ...)
{
    va_list args;

    if(acutest_verbose_level_ < 2)
        return;

    if(acutest_case_name_[0]) {
        acutest_case_already_logged_ = 0;
        acutest_case_name_[0] = '\0';
    }

    if(fmt == NULL)
        return;

    va_start(args, fmt);
    vsnprintf(acutest_case_name_, sizeof(acutest_case_name_) - 1, fmt, args);
    va_end(args);
    acutest_case_name_[sizeof(acutest_case_name_) - 1] = '\0';

    if(acutest_verbose_level_ >= 3) {
        acutest_line_indent_(1);
        acutest_colored_printf_(ACUTEST_COLOR_DEFAULT_INTENSIVE_, "Case %s:\n", acutest_case_name_);
        acutest_test_already_logged_++;
        acutest_case_already_logged_++;
    }
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2b5e
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x2, 0x86bb(%rip)      # 0xb220
jl 0x2bfd
movq %rdi, %r10
cmpb $0x0, 0x87eb(%rip)      # 0xb360
je 0x2b85
andl $0x0, 0x87da(%rip)      # 0xb358
movb $0x0, 0x87db(%rip)      # 0xb360
testq %r10, %r10
je 0x2bfd
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0x87aa(%rip), %rdi      # 0xb360
pushq $0x3f
popq %rsi
movq %r10, %rdx
callq 0x20d0
movb $0x0, 0x87d7(%rip)      # 0xb39f
cmpl $0x3, 0x8651(%rip)      # 0xb220
jl 0x2bfd
pushq $0x1
popq %rdi
callq 0x2965
leaq 0x4582(%rip), %rsi      # 0x7162
leaq 0x8779(%rip), %rdx      # 0xb360
pushq $0xa
popq %rdi
xorl %eax, %eax
callq 0x29de
incl 0x874d(%rip)            # 0xb344
incl 0x875b(%rip)            # 0xb358
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_message_
acutest_message_(const char* fmt, ...)
{
    char buffer[TEST_MSG_MAXSIZE];
    char* line_beg;
    char* line_end;
    va_list args;

    if(acutest_verbose_level_ < 2)
        return;

    /* We allow extra message only when something is already wrong in the
     * current test. */
    if(acutest_current_test_ == NULL  ||  !acutest_cond_failed_)
        return;

    va_start(args, fmt);
    vsnprintf(buffer, TEST_MSG_MAXSIZE, fmt, args);
    va_end(args);
    buffer[TEST_MSG_MAXSIZE-1] = '\0';

    line_beg = buffer;
    while(1) {
        line_end = strchr(line_beg, '\n');
        if(line_end == NULL)
            break;
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%.*s\n", (int)(line_end - line_beg), line_beg);
        line_beg = line_end + 1;
    }
    if(line_beg[0] != '\0') {
        acutest_line_indent_(acutest_case_name_[0] ? 3 : 2);
        printf("%s\n", line_beg);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2c68
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x2, 0x85b1(%rip)      # 0xb220
jl 0x2d41
cmpq $0x0, 0x86cb(%rip)      # 0xb348
je 0x2d41
cmpl $0x0, 0x8716(%rip)      # 0xb3a0
je 0x2d41
movq %rdi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x500(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xd0(%rsp), %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
movq %r10, %rdx
callq 0x20d0
movb $0x0, 0x3ff(%rbx)
pushq $0xa
popq %r14
pushq $0x3
popq %rbp
leaq 0x4487(%rip), %r15      # 0x716c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2170
testq %rax, %rax
je 0x2d23
movq %rax, %r12
cmpb $0x1, 0x8661(%rip)      # 0xb360
movl %ebp, %edi
sbbl $0x0, %edi
callq 0x2965
movl %r12d, %esi
subl %ebx, %esi
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
incq %r12
movq %r12, %rbx
jmp 0x2ce5
cmpb $0x0, (%rbx)
je 0x2d41
cmpb $0x1, 0x8631(%rip)      # 0xb360
sbbl $0x0, %ebp
movl %ebp, %edi
callq 0x2965
movq %rbx, %rdi
callq 0x20a0
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_abort_
void
acutest_abort_(void)
{
    if(acutest_abort_has_jmp_buf_) {
        longjmp(acutest_abort_jmp_buf_, 1);
    } else {
        if(acutest_current_test_ != NULL)
            acutest_fini_(acutest_current_test_->name);
        fflush(stdout);
        fflush(stderr);
        acutest_exit_(ACUTEST_STATE_FAILED);
    }
}

// Assembly:
pushq %rax
cmpb $0x1, 0x849b(%rip)      # 0xb3a4
jne 0x2f1a
leaq 0x849e(%rip), %rdi      # 0xb3b0
pushq $0x1
popq %rsi
callq 0x22e0
movq 0x80af(%rip), %rax      # 0xafd0
movq (%rax), %rdi
callq 0x22a0
movq 0x80c0(%rip), %rax      # 0xaff0
movq (%rax), %rdi
callq 0x22a0
pushq $0x1
popq %rdi
callq 0x2f40
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_count_
static int
acutest_count_(enum acutest_state_ state)
{
    int i, n;

    for(i = 0, n = 0; i < acutest_list_size_; i++) {
        if(acutest_test_data_[i].state == state)
            n++;
    }

    return n;
}

// Assembly:
movl 0x76e4(%rip), %ecx      # 0xb484
movq 0x76e1(%rip), %rdx      # 0xb488
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
shlq $0x4, %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
je 0x3dcc
xorl %r8d, %r8d
cmpl %edi, (%rdx,%rsi)
sete %r8b
addl %r8d, %eax
addq $0x10, %rsi
jmp 0x3db4
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart_test.c
// Function: test_open
void test_open(void)
{
    struct simple_uart *uart;
    pid_t pid;

    pid = setup_loopback();

    uart = simple_uart_open(UART_LOOPBACK_1, 115200, "8N1");
    TEST_ASSERT(uart != NULL);
    simple_uart_close(uart);

    shutdown_loopback(pid);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3e43
movl %eax, %ebx
leaq 0x355c(%rip), %rdi      # 0x7347
leaq 0x3560(%rip), %rdx      # 0x7352
movl $0x1c200, %esi          # imm = 0x1C200
callq 0x54e4
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
leaq 0x3547(%rip), %rsi      # 0x7356
leaq 0x3b11(%rip), %rcx      # 0x7927
leaq 0x354c(%rip), %r8       # 0x7369
pushq $0x41
popq %rdx
xorl %eax, %eax
callq 0x269a
testl %eax, %eax
je 0x3e3e
movq %r14, %rdi
callq 0x54b1
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3eba
callq 0x2f01
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart_test.c
// Function: setup_loopback
static pid_t setup_loopback(void)
{
    pid_t pid;
    char *const args[] = {"socat", "PTY,link=" UART_LOOPBACK_1 ",raw,echo=0,iexten=0",
                          "PTY,link=" UART_LOOPBACK_2 ",raw,echo=0,iexten=0", NULL};
    pid = fork();

    TEST_ASSERT(pid >= 0);

    if (pid == 0) {
        execvp(args[0], args);
    }
    /* Give it time to start */
    usleep(100000);
    return pid;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movaps 0x6f81(%rip), %xmm0     # 0xadd0
movaps %xmm0, 0x10(%rsp)
movaps 0x6f65(%rip), %xmm0     # 0xadc0
movaps %xmm0, (%rsp)
callq 0x23c0
movl %eax, %ebx
movl %eax, %edi
notl %edi
shrl $0x1f, %edi
leaq 0x34e2(%rip), %rsi      # 0x7356
leaq 0x3aac(%rip), %rcx      # 0x7927
leaq 0x3e4a(%rip), %r8       # 0x7ccc
pushq $0x28
popq %rdx
xorl %eax, %eax
callq 0x269a
testl %eax, %eax
je 0x3eb5
testl %ebx, %ebx
jne 0x3ea3
leaq 0x3ddb(%rip), %rdi      # 0x7c76
movq %rsp, %rsi
callq 0x2350
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x2410
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x2f01
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_list_names_
static void
acutest_list_names_(void)
{
    const struct acutest_test_* test;

    printf("Unit tests:\n");
    for(test = &acutest_list_[0]; test->func != NULL; test++)
        printf("  %s\n", test->name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2f3e(%rip), %rdi      # 0x7cf1
callq 0x20a0
leaq 0x5f99(%rip), %r14      # 0xad58
leaq 0x255e(%rip), %rbx      # 0x7324
cmpq $0x0, (%r14)
je 0x4de0
movq -0x8(%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
addq $0x10, %r14
jmp 0x4dc6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/./acutest.h
// Function: acutest_error_
acutest_error_(const char* fmt, ...)
{
    if(acutest_verbose_level_ == 0)
        return;

    if(acutest_verbose_level_ >= 2) {
        va_list args;

        acutest_line_indent_(1);
        if(acutest_verbose_level_ >= 3)
            acutest_colored_printf_(ACUTEST_COLOR_RED_INTENSIVE_, "ERROR: ");
        va_start(args, fmt);
        vprintf(fmt, args);
        va_end(args);
        printf("\n");
    }

    if(acutest_verbose_level_ >= 3) {
        printf("\n");
    }
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
testb %al, %al
je 0x4fbc
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
cmpl $0x2, 0x6244(%rip)      # 0xb220
jl 0x5049
movq %rdi, %rbx
pushq $0x1
popq %rdi
callq 0x2965
cmpl $0x3, 0x6230(%rip)      # 0xb220
jl 0x5003
leaq 0x2c22(%rip), %rsi      # 0x7c1b
pushq $0xb
popq %rdi
xorl %eax, %eax
callq 0x29de
leaq 0x20(%rsp), %rax
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x22b0
pushq $0xa
popq %rdi
callq 0x2050
cmpl $0x3, 0x61e1(%rip)      # 0xb220
jl 0x5049
pushq $0xa
popq %rdi
callq 0x2050
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: simple_uart_write
ssize_t simple_uart_write(struct simple_uart *sc, const void *buffer, size_t len)
{
    if (!sc || !buffer)
        return -EINVAL;
    if (len == 0)
        return 0; // Nothing to write, but not an error

#ifdef _WIN32
    ssize_t r = 0;
    DWORD bytes_written = 0;
    /* TODO: Support char_delay_us */
    if (len > ULONG_MAX)
        len = ULONG_MAX; // avoid overflow at typecast
    if (!WriteFile(sc->port, buffer, (DWORD)len, &bytes_written, NULL))
        return win32_errno();
    r = (ssize_t)bytes_written;
#else
    ssize_t r;
    if (len > SSIZE_MAX)
        len = SSIZE_MAX; // avoid overflow at cast to signed type
    if (sc->char_delay_us > 0) {
        const uint8_t *buf8 = buffer;
        for (size_t i = 0; i < len; i++) {
            ssize_t e = write(sc->fd, &buf8[i], 1);
            if (e < 0)
                return e;
            if (e == 0)
                return (ssize_t)i;
            usleep(sc->char_delay_us);
        }
        r = (ssize_t)len;
    } else {
        r = write(sc->fd, buffer, len);
        if (r < 0)
            r = -errno;
    }
#endif

    if (r > 0 && sc->logfile) {
        fwrite(buffer, (size_t)r, 1, sc->logfile);
        fflush(sc->logfile);
    }

    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x544b
testq %rdx, %rdx
je 0x5450
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rbx, %rdx
cmovbq %rdx, %rbx
cmpl $0x0, 0x4(%rdi)
je 0x5454
xorl %r13d, %r13d
pushq $0x1
popq %r12
cmpq %r13, %rbx
je 0x5475
movl (%r14), %edi
leaq (%r15,%r13), %rsi
movq %r12, %rdx
callq 0x2110
testq %rax, %rax
js 0x549c
je 0x54a1
movl 0x4(%r14), %edi
callq 0x2410
incq %r13
jmp 0x5422
pushq $-0x16
popq %rbx
jmp 0x54a4
xorl %ebx, %ebx
jmp 0x54a4
movl (%r14), %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2110
movq %rax, %rbx
testq %rax, %rax
jns 0x5475
callq 0x2060
movslq (%rax), %rbx
negq %rbx
testq %rbx, %rbx
jle 0x54a4
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x54a4
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2390
movq 0x8(%r14), %rdi
callq 0x22a0
jmp 0x54a4
movq %rax, %rbx
jmp 0x54a4
movq %r13, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: simple_uart_close
int simple_uart_close(struct simple_uart *sc)
{
    if (!sc)
        return -EINVAL;

    /* Close logfile if open to prevent file handle leak */
    if (sc->logfile) {
        fclose(sc->logfile);
        sc->logfile = NULL;
    }

#if defined(__linux__) || defined(__APPLE__)
    close(sc->fd);
#else
    CloseHandle(sc->port);
#endif
    free(sc);

    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x54e0
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x54cd
callq 0x2130
andq $0x0, 0x8(%rbx)
movl (%rbx), %edi
callq 0x21d0
movq %rbx, %rdi
callq 0x2040
xorl %eax, %eax
popq %rbx
retq
pushq $-0x16
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: simple_uart_has_data
int simple_uart_has_data(struct simple_uart *sc)
{
    if (!sc)
        return 0;

#ifdef _WIN32
    COMSTAT cs;
    DWORD r;
    if (!ClearCommError(sc->port, NULL, &cs)) {
        return 0;
    }
    r = cs.cbInQue;
    if (r > INT_MAX)
        r = INT_MAX;
    return (int)r;
#else
    int bytes_available;
    if (ioctl(sc->fd, FIONREAD, &bytes_available) < 0)
        return -errno;
    return bytes_available;
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x5a9a
movl (%rdi), %edi
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
movl $0x541b, %esi           # imm = 0x541B
xorl %eax, %eax
callq 0x21c0
testl %eax, %eax
js 0x5a9e
movl 0xc(%rsp), %ebx
jmp 0x5aa5
xorl %ebx, %ebx
jmp 0x5aa5
callq 0x2060
subl (%rax), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: readfile
static bool readfile(const char *dir, const char *filename, char *result, size_t max_result_len)
{
    FILE *fp;
    size_t len = 0;
    char path[PATH_MAX];
    snprintf(path, sizeof(path), "%s/%s", dir, filename);
    result[0] = '\0';
    if ((fp = fopen(path, "rb")) != NULL) {
        len = fread(result, 1, max_result_len - 1, fp);
        if (len) {
            result[len - 1] = '\0';
        }
        fclose(fp);
    }
    return len != 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdx, %rbx
movq %rsi, %r8
movq %rdi, %rcx
leaq 0x24e8(%rip), %rdx      # 0x8406
xorl %ebp, %ebp
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2190
movb $0x0, (%rbx)
leaq 0x24d0(%rip), %rsi      # 0x840c
movq %r14, %rdi
callq 0x2330
testq %rax, %rax
je 0x5f7c
movq %rax, %r14
pushq $0x1
popq %rsi
movl $0xff, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x20c0
movq %rax, %r15
testq %rax, %rax
je 0x5f6d
movb $0x0, -0x1(%rbx,%r15)
movq %r14, %rdi
callq 0x2130
testq %r15, %r15
setne %bpl
movl %ebp, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: simple_uart_set_logfile
int simple_uart_set_logfile(struct simple_uart *uart, const char *logfile, ...)
{
    va_list ap;
    char *buffer;
    int len;

    if (!uart || !logfile)
        return -EINVAL;

    va_start(ap, logfile);
    len = vasprintf(&buffer, logfile, ap);
    va_end(ap);
    if (len < 0)
        return -errno;
    if (uart->logfile) {
        fclose(uart->logfile);
        uart->logfile = NULL;
    }
    uart->logfile = fopen(buffer, "a");
    if (!uart->logfile) {
        int e = -errno;
        free(buffer);
        return e;
    }
    free(buffer);
    return 0;
}

// Assembly:
pushq %rbx
subq $0xe0, %rsp
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x5fe6
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x6069
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x2120
testl %eax, %eax
js 0x606e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6041
callq 0x2130
andq $0x0, 0x8(%rbx)
movq 0x8(%rsp), %rdi
leaq 0x14dc(%rip), %rsi      # 0x7529
callq 0x2330
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6079
movq 0x8(%rsp), %rdi
callq 0x2040
xorl %ebx, %ebx
jmp 0x608c
pushq $-0x16
popq %rbx
jmp 0x608c
callq 0x2060
xorl %ebx, %ebx
subl (%rax), %ebx
jmp 0x608c
callq 0x2060
xorl %ebx, %ebx
subl (%rax), %ebx
movq 0x8(%rsp), %rdi
callq 0x2040
movl %ebx, %eax
addq $0xe0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: simple_uart_get_pin
int simple_uart_get_pin(struct simple_uart *uart, int pin)
{
    if (!uart)
        return -EINVAL;

#if defined(__linux__) || defined(__APPLE__)
    int status;

    if (ioctl(uart->fd, TIOCMGET, &status) < 0)
        return -errno;

    switch (pin) {
    case SIMPLE_UART_CTS: return (status & TIOCM_CTS) ? 1 : 0;
    case SIMPLE_UART_DSR: return (status & TIOCM_DSR) ? 1 : 0;
    case SIMPLE_UART_DCD: return (status & TIOCM_CAR) ? 1 : 0;
    case SIMPLE_UART_RI: return (status & TIOCM_RI) ? 1 : 0;
    default: return -EINVAL;
    }
#else
    DWORD status;
    if (!GetCommModemStatus(uart->port, &status))
        return win32_errno();
    switch (pin) {
    case SIMPLE_UART_CTS: return (status & MS_CTS_ON) ? 1 : 0;
    case SIMPLE_UART_DSR: return (status & MS_DSR_ON) ? 1 : 0;
    case SIMPLE_UART_DCD: return (status & MS_RLSD_ON) ? 1 : 0;
    case SIMPLE_UART_RI: return (status & MS_RING_ON) ? 1 : 0;
    default: return -EINVAL;
    }
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x62ba
movl %esi, %r14d
movl (%rdi), %edi
xorl %ebx, %ebx
leaq 0x4(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x21c0
testl %eax, %eax
js 0x62bf
pushq $-0x16
popq %rbx
decl %r14d
cmpl $0x4, %r14d
ja 0x62e4
leaq 0x2060(%rip), %rax      # 0x8308
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x4(%rsp), %ebx
shrl $0x5, %ebx
jmp 0x62e1
pushq $-0x16
popq %rbx
jmp 0x62e4
callq 0x2060
subl (%rax), %ebx
jmp 0x62e4
movl 0x4(%rsp), %ebx
shrl $0x6, %ebx
jmp 0x62e1
movl 0x4(%rsp), %ebx
shrl $0x8, %ebx
jmp 0x62e1
movl 0x4(%rsp), %ebx
shrl $0x7, %ebx
andl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndreRenaud[P]simple_uart/simple_uart.c
// Function: simple_uart_set_pin
int simple_uart_set_pin(struct simple_uart *uart, int pin, bool high)
{
    if (!uart)
        return -EINVAL;

#if defined(__linux__) || defined(__APPLE__)
    int bits;

    if (uart->fd < 0)
        return -EINVAL;

    switch (pin) {
    case SIMPLE_UART_RTS: bits = TIOCM_RTS; break;
    case SIMPLE_UART_DTR: bits = TIOCM_DTR; break;
    default: return -EINVAL;
    }
    if (ioctl(uart->fd, high ? TIOCMBIS : TIOCMBIC, &bits) < 0)
        return -errno;

    return 0;
#else
    bool res;
    switch (pin) {
    case SIMPLE_UART_RTS: res = EscapeCommFunction(uart->port, high ? SETRTS : CLRRTS); break;
    case SIMPLE_UART_DTR: res = EscapeCommFunction(uart->port, high ? SETDTR : CLRDTR); break;
    default: return -EINVAL;
    }
    if (!res)
        return win32_errno();
    return 0;
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x630e
movl (%rdi), %edi
pushq $-0x16
popq %rbx
testl %edi, %edi
js 0x6340
testl %esi, %esi
je 0x6313
cmpl $0x4, %esi
jne 0x6340
pushq $0x2
jmp 0x6315
pushq $-0x16
popq %rbx
jmp 0x6340
pushq $0x4
popq %rcx
leaq 0xc(%rsp), %rax
movl %ecx, (%rax)
movzbl %dl, %esi
xorq $0x5417, %rsi           # imm = 0x5417
xorl %ebx, %ebx
movq %rax, %rdx
xorl %eax, %eax
callq 0x21c0
testl %eax, %eax
jns 0x6340
callq 0x2060
xorl %ebx, %ebx
subl (%rax), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/main.cpp
// Function: main
int main ()
{
	A a(Animals::COW);

	std::cout << "size:" << EnumManager<Day>::size() << std::endl;

	for (int DAY = 0; DAY < EnumManager<Day>::size(); DAY++)
		std::cout << static_cast<Day> (DAY) << std::endl;

	Day e = Day::Friday;
	std::string s = EnumManager<Day>::toString(e);
	std::cout << "to string: '" << s << "'" << std::endl;
	e = EnumManager<Day>::toEnum(s);
	std::cout << "from string: " << e << " = " << (int)e << std::endl;

	std::cout << "Name a day: ";
	while (true)
	{
		std::cin >> e;
		std::cout << "day = " << e << std::endl;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
leaq 0xc(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x363c
movq 0x4b54(%rip), %rbx      # 0x6fd0
leaq 0x1bcc(%rip), %rsi      # 0x404f
movq %rbx, %rdi
callq 0x2160
movl 0x4ce7(%rip), %esi      # 0x7178
movq %rax, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20a0
xorl %ebp, %ebp
cmpl 0x4ccf(%rip), %ebp      # 0x7178
jge 0x24c1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25cb
movq %rax, %rdi
callq 0x20a0
incl %ebp
jmp 0x24a3
movl $0x4, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
pushq $0x4
popq %rsi
callq 0x261a
movq 0x4af3(%rip), %rdi      # 0x6fd0
leaq 0x1b71(%rip), %rsi      # 0x4055
callq 0x2160
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x1b63(%rip), %rsi      # 0x4060
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20a0
leaq 0x10(%rsp), %rdi
callq 0x2672
movl %eax, %ebx
movl %eax, 0x8(%rsp)
movq 0x4aac(%rip), %rdi      # 0x6fd0
leaq 0x1b37(%rip), %rsi      # 0x4062
callq 0x2160
movq %rax, %rdi
movl %ebx, %esi
callq 0x25cb
leaq 0x1b3f(%rip), %rsi      # 0x4080
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movl %ebx, %esi
callq 0x2220
movq %rax, %rdi
callq 0x20a0
movq 0x4a6e(%rip), %rdi      # 0x6fd0
leaq 0x1b07(%rip), %rsi      # 0x4070
callq 0x2160
movq 0x4a6b(%rip), %rbx      # 0x6fe0
leaq 0x8(%rsp), %r14
movq 0x4a4f(%rip), %r15      # 0x6fd0
leaq 0x1af5(%rip), %r12      # 0x407d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2698
movq %r15, %rdi
movq %r12, %rsi
callq 0x2160
movl 0x8(%rsp), %esi
movq %rax, %rdi
callq 0x25cb
movq %rax, %rdi
callq 0x20a0
jmp 0x2588
jmp 0x25b6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: EnumManager<Day>::toString[abi:cxx11](Day)
std::string EnumManager<Enum>::toString (const Enum en) {
    auto it = EnumManager<Enum>::enumToStringMap.find (en);  // std::map::find is the fastest lookup method
    if (it != EnumManager<Enum>::enumToStringMap.end())
        return it->second;
    return "[[[Enum to string not found. Programmer made an error]]]";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
leaq 0x4b20(%rip), %rdi      # 0x7150
movq %rax, %rsi
callq 0x30f2
leaq 0x4b19(%rip), %rcx      # 0x7158
cmpq %rcx, %rax
je 0x2655
addq $0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21d0
jmp 0x2669
leaq 0x1a6c(%rip), %rsi      # 0x40c8
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x2a10
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: EnumManager<Day>::toEnum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Enum EnumManager<Enum>::toEnum (const std::string& str) {
    auto it = EnumManager<Enum>::stringToEnumMap.find (str);
    if (it != EnumManager<Enum>::stringToEnumMap.end())
        return it->second;
    return static_cast<Enum> (ENUM_NOT_FOUND);
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x4b0b(%rip), %rdi      # 0x7188
callq 0x3144
leaq 0x4b07(%rip), %rcx      # 0x7190
cmpq %rcx, %rax
je 0x2693
movl 0x40(%rax), %eax
jmp 0x2696
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: std::enable_if<enum_serializable<Day>::value, std::istream&>::type operator>><Day>(std::istream&, Day&)
typename std::enable_if<enum_serializable<Enum>::value, std::istream&>::type operator>>(std::istream& is, Enum& e)
{
    std::string buf;
    is >> buf;
	e = EnumManager<Enum>::toEnum(buf);
    return is;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rsi
callq 0x21b0
leaq 0x8(%rsp), %rdi
callq 0x2672
movl %eax, (%r14)
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 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: EnumManager<Day>::initializeEnumToStringMap[abi:cxx11]()
std::map<Enum, std::string> EnumManager<Enum>::initializeEnumToStringMap() {
    std::map<Enum, std::string> m;
    //for (const auto& x: EnumConversions<Enum>::enumToStringVector)
	for (const auto& x: splitStringToVector(EnumConversions<Enum>::enumToStringStr))
		m[x.first] = x.second;
    return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x18eb(%rip), %rsi      # 0x4010
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2a10
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x28a2
leaq 0x20(%rsp), %rdi
callq 0x2090
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r15
cmpq %r15, %r14
je 0x277c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a4c
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
addq $0x20, %r14
jmp 0x2757
leaq 0x8(%rsp), %rdi
callq 0x2a9a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2090
jmp 0x27b4
movq %rax, %r14
jmp 0x27b4
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2a9a
movq %rbx, %rdi
callq 0x30a8
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: EnumManager<Day>::initializeStringToEnumMap[abi:cxx11]()
std::map<std::string, Enum> EnumManager<Enum>::initializeStringToEnumMap() {
    std::map<std::string, Enum> m;
    //for (const auto& x: EnumConversions<Enum>::enumToStringVector)
	for (const auto& x: splitStringToVector(EnumConversions<Enum>::enumToStringStr))
		m[x.second] = x.first;
    return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x1818(%rip), %rsi      # 0x4010
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2a10
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x28a2
leaq 0x28(%rsp), %rdi
callq 0x2090
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r15, %r14
je 0x2849
movl (%r14), %ebp
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31ce
movl %ebp, (%rax)
addq $0x20, %r14
jmp 0x282a
leaq 0x10(%rsp), %rdi
callq 0x2a9a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2090
jmp 0x2882
movq %rax, %r14
jmp 0x2882
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2a9a
movq %rbx, %rdi
callq 0x35f2
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: EnumManager<Day>::splitStringToVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static EnumToStringVector splitStringToVector(const std::string& str) {
		const char delim = ',';
		EnumToStringVector tokens;
		std::stringstream ss(str);
		std::string item;
		while (std::getline(ss, item, delim)) {
			tokens.push_back(std::make_pair(static_cast<Enum>(tokens.size()), trim(item)));
		}
		return tokens;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x70(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x2200
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %r12
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r13
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x2c
popq %rdx
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x299f
movq (%rbx), %r14
movq 0x8(%rbx), %r15
movq %r13, %rdi
leaq 0x50(%rsp), %rsi
callq 0x2abc
subq %r14, %r15
movq %r15, %rax
cqto
pushq $0x28
popq %rcx
idivq %rcx
movl %eax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq 0x8(%rsp), %rax
cmpq %rbp, %rax
je 0x2958
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2961
movups (%rbp), %xmm0
movups %xmm0, (%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rbp, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2bb6
leaq 0x30(%rsp), %rdi
callq 0x2090
movq %r13, %rdi
callq 0x2090
jmp 0x28ee
leaq 0x50(%rsp), %rdi
callq 0x2090
leaq 0x70(%rsp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x29ff
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x2090
jmp 0x29eb
jmp 0x29e8
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x2090
leaq 0x70(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2a9a
movq %r14, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O2/michalfapso[P]enum_strings/./enum_conversions.h
// Function: EnumManager<Day>::trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string trim(std::string const& str)
	{
		if(str.empty())
			return str;

		std::size_t first = str.find_first_not_of(' ');
		std::size_t last  = str.find_last_not_of(' ');
		return str.substr(first, last-first+1);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2b06
pushq $0x20
popq %rbp
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x2150
movq %rax, %r15
pushq $-0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
callq 0x20d0
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2190
jmp 0x2b11
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/record.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: record N fs <duration> <device> <channelOffset>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate,\n";
  std::cout << "    duration = optional time in seconds to record (default = 2.0),\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    and channelOffset = an optional channel offset on the device (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbx
movq 0x7a3c(%rip), %rbx      # 0xcfd0
leaq 0x3a7d(%rip), %rsi      # 0x9018
movq %rbx, %rdi
callq 0x51d0
leaq 0x3aa8(%rip), %rsi      # 0x9052
movq %rbx, %rdi
callq 0x51d0
leaq 0x3abc(%rip), %rsi      # 0x9075
movq %rbx, %rdi
callq 0x51d0
leaq 0x3ac8(%rip), %rsi      # 0x9090
movq %rbx, %rdi
callq 0x51d0
leaq 0x3afd(%rip), %rsi      # 0x90d4
movq %rbx, %rdi
callq 0x51d0
leaq 0x3b22(%rip), %rsi      # 0x9108
movq %rbx, %rdi
callq 0x51d0
xorl %edi, %edi
callq 0x5260
// File: /workspace/github_cpp_makefile_star2_O2/tobias93[P]piano/rtaudio/tests/record.cpp
// Function: input(void*, void*, unsigned int, double, unsigned int, void*)
int input( void * /*outputBuffer*/, void *inputBuffer, unsigned int nBufferFrames,
           double /*streamTime*/, RtAudioStreamStatus /*status*/, void *data )
{
  InputData *iData = (InputData *) data;

  // Simply copy the data to our allocated buffer.
  unsigned int frames = nBufferFrames;
  if ( iData->frameCounter + nBufferFrames > iData->totalFrames ) {
    frames = iData->totalFrames - iData->frameCounter;
    iData->bufferBytes = frames * iData->channels * sizeof( MY_TYPE );
  }

  unsigned long offset = iData->frameCounter * iData->channels;
  memcpy( iData->buffer+offset, inputBuffer, iData->bufferBytes );
  iData->frameCounter += frames;

  if ( iData->frameCounter >= iData->totalFrames ) return 2;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq 0x10(%r8), %rcx
movq 0x18(%r8), %rdi
movl %edx, %r14d
leaq (%rdi,%r14), %rax
cmpq %rcx, %rax
jbe 0x5627
subq %rdi, %rcx
movl 0x20(%rbx), %eax
movl %eax, %edx
imull %ecx, %edx
addq %rdx, %rdx
movq %rdx, 0x8(%rbx)
movl %ecx, %r14d
jmp 0x562e
movl 0x20(%rbx), %eax
movq 0x8(%rbx), %rdx
movl %eax, %eax
imulq %rax, %rdi
addq %rdi, %rdi
addq (%rbx), %rdi
callq 0x5180
addq 0x18(%rbx), %r14
xorl %eax, %eax
cmpq 0x10(%rbx), %r14
setae %al
movq %r14, 0x18(%rbx)
addl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/avg_price.cc
// Function: main
int main()
{
    Sales_item total; // variable to hold data for the next transaction

    // read the first transaction and ensure that there are data to process
    if (std::cin >> total) {
        Sales_item trans; // variable to hold the running sum
        // read and process the remaining transactions
        while (std::cin >> trans) {
            // if we're still processing the same book
            if (total.isbn() == trans.isbn()) {
                total += trans; // update the running total

            } else {
                // print results for the previous book
                std::cout << total << std::endl;
                total = trans;  // total now refers to the next book
            }
        }
        std::cout << total << std::endl; // print the last transaction

    } else {
        // no input! warn the user
        std::cerr << "No data?!" << std::endl;
        return -1;  // indicate failure
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq 0x2b73(%rip), %rbx      # 0x3fd8
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x12bc
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x14a2
movq 0x2b6a(%rip), %rdi      # 0x3ff0
leaq 0xb79(%rip), %rsi       # 0x2006
callq 0x10b0
movq %rax, %rdi
callq 0x1050
pushq $-0x1
popq %rbx
jmp 0x15aa
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andl $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq -0x88(%rbp), %r14
leaq -0xa8(%rbp), %r15
leaq -0x58(%rbp), %r12
leaq -0xc8(%rbp), %r13
movq 0x2afd(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
callq 0x12bc
movq 0x2aee(%rip), %rcx      # 0x3fd8
movq (%rcx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rcx,%rax)
jne 0x1580
movq %r15, %rdi
movq %r12, %rsi
callq 0x10e0
movq %r13, %rdi
movq %r14, %rbx
movq %r14, %rsi
callq 0x10e0
movq %r15, %rdi
movq %r13, %rsi
callq 0x1645
movl %eax, %r14d
movq %r13, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1040
testb %r14b, %r14b
je 0x1552
movl -0x68(%rbp), %eax
addl %eax, -0x38(%rbp)
movsd -0x60(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq %rbx, %r14
jmp 0x14d4
movq 0x2a6f(%rip), %rdi      # 0x3fc8
movq %r12, %rsi
callq 0x1353
movq %rbx, %r14
movq 0x2a5d(%rip), %rdi      # 0x3fc8
callq 0x1050
movq %r12, %rdi
movq %r14, %rsi
callq 0x1668
jmp 0x14d4
movq 0x2a41(%rip), %rdi      # 0x3fc8
leaq -0x58(%rbp), %rsi
callq 0x1353
movq 0x2a31(%rip), %rdi      # 0x3fc8
callq 0x1050
leaq -0x88(%rbp), %rdi
callq 0x1040
xorl %ebx, %ebx
leaq -0x58(%rbp), %rdi
callq 0x1040
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15e1
movq %rax, %rbx
jmp 0x15f0
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x1040
jmp 0x15e4
jmp 0x15e1
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x1040
leaq -0x58(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1120
nop