LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/venGaza[P]starwars/src/DetentionBlock.cpp
// Function: DetentionBlock::printChoices()
void DetentionBlock::printChoices() {
    if (!doorOpen) {
        cout << "1) North - Core Reactor" << endl
             << "2) Item Inventory " << endl
             << "3) Look around" << endl
             << "4) Open Cell Door" << endl << endl;
    } else {
        cout << "1) North " << endl
        << "2) Item Inventory " << endl
        << "3) Look around" << endl << endl;
    }
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x68(%rdi)
je 0x6e33
movq 0x722a(%rip), %rbx      # 0xdfd0
leaq 0x2f4f(%rip), %rsi      # 0x9cfc
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x1584(%rip), %rsi      # 0x836f
movl $0x12, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x1559(%rip), %rsi      # 0x8382
movl $0xe, %edx
jmp 0x6f00
movq 0x7196(%rip), %rbx      # 0xdfd0
leaq 0x2e91(%rip), %rsi      # 0x9cd2
movl $0x17, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x14f0(%rip), %rsi      # 0x836f
movl $0x12, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x14c5(%rip), %rsi      # 0x8382
movl $0xe, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x2def(%rip), %rsi      # 0x9cea
movl $0x11, %edx
movq %rax, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x68(%rsi), %bpl
movq 0x7059(%rip), %r15      # 0xdfd0
leaq 0x129c(%rip), %rsi      # 0x821a
movl $0x28, %edx
movq %r15, %rdi
callq 0x2160
testb %bpl, %bpl
je 0x700d
callq 0x678c
leaq 0x8(%rsp), %r14
movl %eax, (%r14)
movq %r14, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x3d90
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl (%r14), %eax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
cmpl $0x2, %eax
je 0x708d
cmpl $0x1, %eax
jne 0x70a5
leaq 0x124a(%rip), %rsi      # 0x8243
leaq 0x1248(%rip), %rdx      # 0x8248
movq %rbx, %rdi
callq 0x2b74
jmp 0x711d
callq 0x678c
leaq 0xc(%rsp), %r12
movl %eax, (%r12)
movq %r12, %rdi
movl $0x1, %esi
movl $0x4, %edx
callq 0x3d90
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl (%r12), %eax
cmpl $0x3, %eax
je 0x70dc
cmpl $0x2, %eax
je 0x70bd
cmpl $0x1, %eax
jne 0x70fb
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x11ca(%rip), %rsi      # 0x8243
leaq 0x11c8(%rip), %rdx      # 0x8248
movq %rbx, %rdi
callq 0x2b74
jmp 0x711d
leaq 0x11c0(%rip), %rsi      # 0x8254
leaq 0x11be(%rip), %rdx      # 0x8259
movq %rbx, %rdi
callq 0x2b74
jmp 0x711d
leaq 0x11ae(%rip), %rsi      # 0x825a
leaq 0x11ab(%rip), %rdx      # 0x825e
movq %rbx, %rdi
callq 0x2b74
jmp 0x711d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1189(%rip), %rsi      # 0x8254
leaq 0x1187(%rip), %rdx      # 0x8259
movq %rbx, %rdi
callq 0x2b74
jmp 0x711d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1170(%rip), %rsi      # 0x825a
leaq 0x116d(%rip), %rdx      # 0x825e
movq %rbx, %rdi
callq 0x2b74
jmp 0x711d
movb $0x1, 0x68(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1b21(%rip), %rsi      # 0x8c2f
leaq 0x1b1e(%rip), %rdx      # 0x8c33
movq %rbx, %rdi
callq 0x2b74
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7139
jmp 0x7139
jmp 0x7139
jmp 0x7139
jmp 0x7139
jmp 0x7139
movq %rax, %rdi
callq 0x2220
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7548
leaq 0x6bd8(%rip), %rax      # 0xdd30
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rdx
leaq 0x2aab(%rip), %rcx      # 0x9c15
movl $0xe, %r8d
xorl %esi, %esi
callq 0x21c0
leaq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rdx
leaq 0x2bad(%rip), %rcx      # 0x9d33
movl $0x86, %r8d
xorl %esi, %esi
callq 0x21c0
movq $0x0, 0x48(%rbx)
movl $0x68, %edi
callq 0x2140
movq %rax, %r15
movq %rax, %rdi
callq 0x2c0c
movq %r15, 0x50(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76ae
movl $0x68, %edi
callq 0x2140
movq %rax, %r15
movq %rax, %rdi
callq 0x2dd4
movq %r15, 0x60(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76c0
movl $0x68, %edi
callq 0x2140
movq %rax, %r15
movq %rax, %rdi
callq 0x2c0c
movq %r15, 0x58(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x76ba
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7211
jmp 0x7211
movq %rax, %r14
movl $0x68, %esi
movq %r15, %rdi
callq 0x2150
jmp 0x7226
movq %rax, %r14
movq %rbx, %rdi
callq 0x75f6
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x681d(%rip), %rax      # 0xdd78
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0xba4(%rip), %rcx       # 0x8131
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x21c0
movq 0x30(%r15), %rdx
leaq 0xb8a(%rip), %rcx       # 0x8131
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x21c0
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%r15)
movups %xmm0, 0x48(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x75e3
movq (%r13), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2299
movq %r15, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x89b9(%rip)      # 0xb494
jne 0x2b40
cmpl $0x2, %ebx
leaq 0x4dfc(%rip), %rax      # 0x78e3
leaq 0x4df1(%rip), %rsi      # 0x78df
cmoveq %rax, %rsi
leaq 0x4ded(%rip), %rcx      # 0x78e6
leaq 0x4fc7(%rip), %r8       # 0x7ac7
cmoveq %rcx, %r8
testl %ebx, %ebx
movl 0x89a4(%rip), %edx      # 0xb4b0
movq 0x8835(%rip), %rcx      # 0xb348
movq (%rcx), %rcx
cmoveq %rax, %rsi
incl %edx
leaq 0x4dae(%rip), %rdi      # 0x78d1
xorl %eax, %eax
callq 0x2180
testl %ebx, %ebx
jne 0x2b57
cmpl $0x0, 0x897f(%rip)      # 0xb4b4
je 0x2b57
leaq 0x4db0(%rip), %rdi      # 0x78ee
jmp 0x2bb9
testl %ebx, %ebx
je 0x2b5c
cmpl $0x2, %ebx
jne 0x2b6a
leaq 0x4dae(%rip), %r14      # 0x78fe
movl $0xd, %ebp
jmp 0x2b76
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4d98(%rip), %r14      # 0x78fb
movl $0xc, %ebp
jmp 0x2b76
leaq 0x4d95(%rip), %r14      # 0x7906
movl $0xb, %ebp
leaq 0x4d90(%rip), %rdi      # 0x790d
xorl %eax, %eax
callq 0x2180
leaq 0x4dd4(%rip), %rsi      # 0x795f
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2c74
leaq 0x4d72(%rip), %rdi      # 0x7910
xorl %eax, %eax
callq 0x2180
testl %ebx, %ebx
jne 0x2c00
cmpl $0x0, 0x8904(%rip)      # 0xb4b4
je 0x2c00
leaq 0x4600(%rip), %rdi      # 0x71b9
xorl %eax, %eax
callq 0x2180
movq 0x8901(%rip), %rax      # 0xb4c8
movq 0x8902(%rip), %rcx      # 0xb4d0
subq 0x88e3(%rip), %rax      # 0xb4b8
cvtsi2sd %rax, %xmm1
subq 0x88df(%rip), %rcx      # 0xb4c0
cvtsi2sd %rcx, %xmm0
divsd 0x441a(%rip), %xmm0     # 0x7008
addsd %xmm1, %xmm0
leaq 0x4d1a(%rip), %rdi      # 0x7913
movb $0x1, %al
callq 0x2180
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O3/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 %ebx, %ebx
cmpb $0x1, 0x8876(%rip)      # 0xb494
jne 0x2c2c
decl %ebx
movl $0x23, %edi
callq 0x2050
cmpl $0x11, %ebx
jl 0x2c58
leaq 0x4d27(%rip), %r14      # 0x795f
leaq 0x4481(%rip), %r15      # 0x70c0
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
leal -0x10(%rbx), %esi
cmpl $0x20, %ebx
movl %esi, %ebx
ja 0x2c3f
jmp 0x2c5a
movl %ebx, %esi
leaq 0x4cbd(%rip), %rdi      # 0x791e
leaq 0x4458(%rip), %rdx      # 0x70c0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2df4
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, 0x8425(%rip)      # 0xb220
jl 0x2e9c
movq %rdi, %r10
cmpb $0x0, 0x8555(%rip)      # 0xb360
je 0x2e1e
movl $0x0, 0x8541(%rip)      # 0xb358
movb $0x0, 0x8542(%rip)      # 0xb360
testq %r10, %r10
je 0x2e9c
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 0x8511(%rip), %rdi      # 0xb360
movl $0x3f, %esi
movq %r10, %rdx
callq 0x20d0
movb $0x0, 0x853c(%rip)      # 0xb39f
cmpl $0x3, 0x83b6(%rip)      # 0xb220
jl 0x2e9c
movl $0x1, %edi
callq 0x2c0e
leaq 0x431d(%rip), %rsi      # 0x719a
leaq 0x84dc(%rip), %rdx      # 0xb360
movl $0xa, %edi
xorl %eax, %eax
callq 0x2c74
incl 0x84ae(%rip)            # 0xb344
incl 0x84bc(%rip)            # 0xb358
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
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 0x2f04
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, 0x8315(%rip)      # 0xb220
jl 0x2ff9
cmpq $0x0, 0x842f(%rip)      # 0xb348
je 0x2ff9
cmpl $0x0, 0x847a(%rip)      # 0xb3a0
je 0x2ff9
movq %rdi, %r10
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0x4f0(%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)
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
testq %rax, %rax
je 0x2fd8
movq %rax, %r14
leaq 0xd0(%rsp), %rbx
leaq 0x420d(%rip), %r15      # 0x71a4
cmpb $0x1, 0x83c2(%rip)      # 0xb360
movl $0x3, %edi
sbbl $0x0, %edi
callq 0x2c0e
movl %r14d, %esi
subl %ebx, %esi
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2180
movq %r14, %rbx
incq %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movq %rax, %r14
testq %rax, %rax
jne 0x2f97
cmpb $0x0, (%rbx)
je 0x2ff9
cmpb $0x1, 0x837c(%rip)      # 0xb360
movl $0x3, %edi
sbbl $0x0, %edi
callq 0x2c0e
movq %rbx, %rdi
callq 0x20a0
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x81da(%rip)      # 0xb3a4
jne 0x31dd
leaq 0x81dd(%rip), %rdi      # 0xb3b0
movl $0x1, %esi
callq 0x22e0
movq 0x7dec(%rip), %rax      # 0xafd0
movq (%rax), %rdi
callq 0x22a0
movq 0x7dfd(%rip), %rax      # 0xaff0
movq (%rax), %rdi
callq 0x22a0
movl $0x1, %edi
callq 0x3205
// File: /workspace/github_cpp_makefile_star2_O3/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 0x416a
movl %eax, %ebx
leaq 0x3282(%rip), %rdi      # 0x737f
leaq 0x3286(%rip), %rdx      # 0x738a
movl $0x1c200, %esi          # imm = 0x1C200
callq 0x5a07
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
leaq 0x326d(%rip), %rsi      # 0x738e
leaq 0x3837(%rip), %rcx      # 0x795f
leaq 0x3272(%rip), %r8       # 0x73a1
movl $0x41, %edx
xorl %eax, %eax
callq 0x28df
testl %eax, %eax
je 0x4165
movq %r14, %rdi
callq 0x59cf
movl %ebx, %edi
movl $0x1, %esi
callq 0x2270
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22f0
callq 0x31c2
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6c5a(%rip), %xmm0     # 0xadd0
movaps %xmm0, 0x10(%rsp)
movaps 0x6c3e(%rip), %xmm0     # 0xadc0
movaps %xmm0, (%rsp)
callq 0x23c0
movl %eax, %ebx
movl %eax, %edi
notl %edi
shrl $0x1f, %edi
leaq 0x31f3(%rip), %rsi      # 0x738e
leaq 0x37bd(%rip), %rcx      # 0x795f
leaq 0x3b5b(%rip), %r8       # 0x7d04
movl $0x28, %edx
xorl %eax, %eax
callq 0x28df
testl %eax, %eax
je 0x41de
testl %ebx, %ebx
jne 0x41cc
leaq 0x3aea(%rip), %rdi      # 0x7cae
movq %rsp, %rsi
callq 0x2350
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x2410
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x31c2
// File: /workspace/github_cpp_makefile_star2_O3/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 0x53fe
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, 0x5e02(%rip)      # 0xb220
jl 0x5493
movq %rdi, %rbx
movl $0x1, %edi
callq 0x2c0e
cmpl $0x3, 0x5dec(%rip)      # 0xb220
jl 0x5449
leaq 0x2816(%rip), %rsi      # 0x7c53
movl $0xb, %edi
xorl %eax, %eax
callq 0x2c74
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
movl $0xa, %edi
callq 0x2050
cmpl $0x3, 0x5d99(%rip)      # 0xb220
jl 0x5493
movl $0xa, %edi
callq 0x2050
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
movq $-0x16, %rbx
orb %al, %cl
jne 0x59c0
testq %rdx, %rdx
je 0x596a
movq %rsi, %r15
movq %rdi, %r14
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rbx, %rdx
cmovbq %rdx, %rbx
cmpl $0x0, 0x4(%rdi)
je 0x596e
xorl %r12d, %r12d
movl (%r14), %edi
leaq (%r15,%r12), %rsi
movl $0x1, %edx
callq 0x2110
testq %rax, %rax
js 0x59b8
je 0x59bd
movl 0x4(%r14), %edi
callq 0x2410
incq %r12
cmpq %r12, %rbx
jne 0x593f
jmp 0x598f
xorl %ebx, %ebx
jmp 0x59c0
movl (%r14), %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2110
movq %rax, %rbx
testq %rax, %rax
jns 0x598f
callq 0x2060
movslq (%rax), %rbx
negq %rbx
testq %rbx, %rbx
jle 0x59c0
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x59c0
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2390
movq 0x8(%r14), %rdi
callq 0x22a0
jmp 0x59c0
movq %rax, %rbx
jmp 0x59c0
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x605c
movl (%rdi), %edi
xorl %ebx, %ebx
leaq 0xc(%rsp), %rdx
movl $0x541b, %esi           # imm = 0x541B
xorl %eax, %eax
callq 0x21c0
testl %eax, %eax
js 0x6060
movl 0xc(%rsp), %ebx
jmp 0x6067
xorl %ebx, %ebx
jmp 0x6067
callq 0x2060
subl (%rax), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f3d(%rip), %rdx      # 0x843e
xorl %ebp, %ebp
movq %rsp, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %r14, %rdi
xorl %eax, %eax
callq 0x2190
movb $0x0, (%rbx)
leaq 0x1f25(%rip), %rsi      # 0x8444
movq %r14, %rdi
callq 0x2330
testq %rax, %rax
je 0x6561
movq %rax, %r14
movl $0x1, %esi
movl $0xff, %edx
movq %rbx, %rdi
movq %rax, %rcx
callq 0x20c0
movq %rax, %r15
testq %rax, %rax
je 0x6552
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_O3/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 %rbp
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x65cc
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
movl $0xffffffea, %ebp       # imm = 0xFFFFFFEA
orb %al, %cl
jne 0x6679
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x2120
testl %eax, %eax
js 0x665b
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x6633
callq 0x2130
movq $0x0, 0x8(%rbx)
movq 0x8(%rsp), %rdi
leaq 0xf22(%rip), %rsi       # 0x7561
callq 0x2330
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x6666
movq 0x8(%rsp), %rdi
callq 0x2040
xorl %ebp, %ebp
jmp 0x6679
callq 0x2060
xorl %ebp, %ebp
subl (%rax), %ebp
jmp 0x6679
callq 0x2060
xorl %ebp, %ebp
subl (%rax), %ebp
movq 0x8(%rsp), %rdi
callq 0x2040
movl %ebp, %eax
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x68e9
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 0x68f0
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
decl %r14d
cmpl $0x4, %r14d
ja 0x6915
leaq 0x1a69(%rip), %rax      # 0x8340
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x4(%rsp), %ebx
shrl $0x5, %ebx
jmp 0x6912
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
jmp 0x6915
callq 0x2060
subl (%rax), %ebx
jmp 0x6915
movl 0x4(%rsp), %ebx
shrl $0x6, %ebx
jmp 0x6912
movl 0x4(%rsp), %ebx
shrl $0x8, %ebx
jmp 0x6912
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_O3/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 0x6944
movl (%rdi), %edi
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
testl %edi, %edi
js 0x697a
testl %esi, %esi
je 0x694b
cmpl $0x4, %esi
jne 0x697a
movl $0x2, %ecx
jmp 0x6950
movl $0xffffffea, %ebx       # imm = 0xFFFFFFEA
jmp 0x697a
movl $0x4, %ecx
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 0x697a
callq 0x2060
xorl %ebx, %ebx
subl (%rax), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
movq 0x59f5(%rip), %rcx      # 0x8158
testq %rcx, %rcx
je 0x2796
leaq 0x59e1(%rip), %rax      # 0x8150
xorl %edx, %edx
cmpl %esi, 0x20(%rcx)
setl %dl
cmovgeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x276f
leaq 0x59c4(%rip), %rcx      # 0x8150
cmpq %rcx, %rax
je 0x2796
cmpl %esi, 0x20(%rax)
jle 0x27b8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2924(%rip), %rsi      # 0x50c8
leaq 0x2955(%rip), %rdx      # 0x5100
movq %rbx, %rdi
callq 0x2d90
movq %rbx, %rax
popq %rbx
retq
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x30f4
jmp 0x27b3
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %rsi
callq 0x21c0
leaq 0x5979(%rip), %rdi      # 0x8180
movq %rsp, %rsi
callq 0x3410
leaq 0x5972(%rip), %rcx      # 0x8188
cmpq %rcx, %rax
je 0x2820
movl 0x40(%rax), %eax
jmp 0x2825
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%r14)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x283e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2864
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x276b(%rip), %rsi      # 0x5010
leaq 0x27a2(%rip), %rdx      # 0x504e
leaq 0x8(%rsp), %rdi
callq 0x2d90
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2a60
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x28dc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %r14
movq 0x30(%rsp), %r15
cmpq %r15, %r14
je 0x290b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c5e
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x20c0
addq $0x20, %r14
jmp 0x28e6
leaq 0x28(%rsp), %rdi
callq 0x2cc4
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2950
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x2950
movq %rax, %r14
jmp 0x2950
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x2cc4
movq %rbx, %rdi
callq 0x33c2
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2670(%rip), %rsi      # 0x5010
leaq 0x26a7(%rip), %rdx      # 0x504e
movq %rsp, %rdi
callq 0x2d90
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x2a60
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x29d2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %r15
cmpq %r15, %r14
je 0x29fb
movl (%r14), %ebp
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x349a
movl %ebp, (%rax)
addq $0x20, %r14
jmp 0x29dc
leaq 0x20(%rsp), %rdi
callq 0x2cc4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2a40
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x2a40
movq %rax, %r14
jmp 0x2a40
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2cc4
movq %rbx, %rdi
callq 0x3896
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, 0x10(%rdi)
leaq 0x70(%rsp), %rdi
movl $0x18, %edx
callq 0x21f0
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %r12
leaq 0x18(%rsp), %rbp
leaq 0x50(%rsp), %r15
leaq 0x70(%rsp), %rdi
movq %r15, %rsi
movl $0x2c, %edx
callq 0x2240
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2b88
movq (%rbx), %r13
movq 0x8(%rbx), %r14
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2d22
subq %r13, %r14
shrq $0x3, %r14
imull $0xcccccccd, %r14d, %eax # imm = 0xCCCCCCCD
movl %eax, 0x28(%rsp)
movq %r12, 0x30(%rsp)
movq 0x8(%rsp), %rax
cmpq %rbp, %rax
je 0x2b1e
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x2b27
movups (%rbp), %xmm0
movups %xmm0, (%r12)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rbp, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %rbx, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2e26
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x2b68
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2ab4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x2ab4
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x2ba4
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x540d(%rip), %rsi      # 0x7fb8
leaq 0x70(%rsp), %rdi
callq 0x2110
leaq 0xf0(%rsp), %rdi
callq 0x2070
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 0x2c4e
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x2bf6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2c14
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x2c14
jmp 0x2c11
movq %rax, %r14
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x2c30
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x5381(%rip), %rsi      # 0x7fb8
leaq 0x70(%rsp), %rdi
callq 0x2110
leaq 0xf0(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2cc4
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2d71
movq %r14, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x2150
movq %rax, %r15
movq %r14, %rdi
movl $0x20, %esi
movq $-0x1, %rdx
callq 0x20e0
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2190
jmp 0x2d86
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x30f4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4697
subq %rdi, %rcx
movl 0x20(%rbx), %eax
movl %eax, %edx
imull %ecx, %edx
addq %rdx, %rdx
movq %rdx, 0x8(%rbx)
movl %ecx, %r14d
jmp 0x469e
movl 0x20(%rbx), %eax
movq 0x8(%rbx), %rdx
movl %eax, %eax
imulq %rax, %rdi
addq %rdi, %rdi
addq (%rbx), %rdi
callq 0x41a0
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_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: primitive::operator>>(std::istream&, primitive::config_t&)
istream & operator >> (istream & in, config_t & a) {
        int w, h, t, s, n; in >> w >> h >> t >> s >> n;
        assert (w == width);
        assert (h == height);
        assert (t == pack_size);
        assert (s == erasing_sum);
        assert (n == turn_number);
        a.packs.resize(turn_number);
        repeat (i,n) in >> a.packs[i];
        return in;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14(%rsp), %rsi
callq 0x20e0
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x20e0
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x20e0
leaq 0x4(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x20e0
movl $0x1f4, %esi            # imm = 0x1F4
movq %r14, %rdi
callq 0x459a
cmpl $0x0, (%r15)
jle 0x26aa
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x45d8
incq %r12
movslq 0x4(%rsp), %rax
addq $0x9, %r15
cmpq %rax, %r12
jl 0x268b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: primitive::operator>>(std::istream&, primitive::input_t&)
istream & operator >> (istream & in, input_t & a) {
        in >> a.turn >> a.remaining_time;
        in >>     a.self_obstacles >>     a.self_field;
        in >> a.opponent_obstacles >> a.opponent_field;
        assert (a.self_obstacles == 0 or a.opponent_obstacles == 0);
        return in;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20e0
leaq 0x4(%r14), %rsi
movq %rax, %rdi
callq 0x20e0
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x20e0
leaq 0xc(%r14), %rsi
movq %rax, %rdi
callq 0x4687
leaq 0xac(%r14), %rsi
movq %rbx, %rdi
callq 0x20e0
addq $0xb0, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x4687
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: primitive::rotate(primitive::blocks_t<3ul, 3ul>, int)
pack_t rotate(pack_t a, rotate_t r) {
        assert (pack_size == 3);
        pack_t b;
        switch (r % 4 + (r < 0 ? 4 : 0)) {
            case 0: b = a; break;
            case 1: repeat (x, pack_size) repeat (y, pack_size) b.at[x][y] = a.at[2-y][  x]; break;
            case 2: repeat (x, pack_size) repeat (y, pack_size) b.at[x][y] = a.at[2-x][2-y]; break;
            case 3: repeat (x, pack_size) repeat (y, pack_size) b.at[x][y] = a.at[  y][2-x]; break;
        }
        return b;
    }

// Assembly:
movq %rdi, -0x20(%rsp)
movb %sil, -0x18(%rsp)
leal 0x3(%rdx), %eax
testl %edx, %edx
cmovnsl %edx, %eax
andl $-0x4, %eax
movl %edx, %ecx
subl %eax, %ecx
shrl $0x1f, %edx
leal (%rcx,%rdx,4), %eax
cmpl $0x3, %eax
ja 0x2893
leaq 0xc8b5(%rip), %rcx      # 0xf080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb -0x18(%rsp), %al
movb %al, -0x8(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0x2893
leaq -0x10(%rsp), %rax
leaq -0x18(%rsp), %rcx
xorl %edx, %edx
movq %rax, %rsi
xorl %edi, %edi
movb (%rcx,%rdi), %r8b
movb %r8b, (%rsi)
decq %rdi
incq %rsi
cmpq $-0x3, %rdi
jne 0x27fc
incq %rdx
addq $-0x3, %rcx
addq $0x3, %rax
cmpq $0x3, %rdx
jne 0x27f7
jmp 0x2893
leaq -0x10(%rsp), %rax
leaq -0x1e(%rsp), %rcx
xorl %edx, %edx
movq $-0x3, %rsi
movq %rcx, %rdi
movb (%rdi), %r8b
movb %r8b, 0x3(%rax,%rsi)
addq $0x3, %rdi
incq %rsi
jne 0x2838
incq %rdx
addq $0x3, %rax
decq %rcx
cmpq $0x3, %rdx
jne 0x282e
jmp 0x2893
leaq -0x20(%rsp), %rax
leaq -0x10(%rsp), %rcx
xorl %edx, %edx
movl $0x6, %esi
movq %rcx, %rdi
movb (%rax,%rsi), %r8b
movb %r8b, (%rdi)
addq $-0x3, %rsi
incq %rdi
cmpq $-0x3, %rsi
jne 0x286f
incq %rdx
incq %rax
addq $0x3, %rcx
cmpq $0x3, %rdx
jne 0x2867
movq -0x10(%rsp), %rax
movb -0x8(%rsp), %dl
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: primitive::fill_obstacles(primitive::blocks_t<3ul, 3ul>, int)
pack_t fill_obstacles(pack_t a, int obstacles) {
        repeat_reverse (y, pack_size) { // yが先
            repeat (x, pack_size) {
                if (obstacles and a.at[x][y] == empty_block) {
                    a.at[x][y] = obstacle_block;
                    obstacles -= 1;
                }
            }
        }
        return a;
    }

// Assembly:
leaq -0xe(%rsp), %rax
movq %rdi, -0x2(%rax)
movb %sil, 0x6(%rax)
movl $0x2, %ecx
xorl %esi, %esi
testl %edx, %edx
je 0x28c3
cmpb $0x0, (%rax,%rsi)
jne 0x28c5
movb $0xb, (%rax,%rsi)
decl %edx
jmp 0x28c5
xorl %edx, %edx
addq $0x3, %rsi
cmpq $0x9, %rsi
jne 0x28b1
decq %rax
subq $0x1, %rcx
jae 0x28af
movq -0x10(%rsp), %rax
movb -0x8(%rsp), %dl
retq
// File: /workspace/github_cpp_makefile_star2_O3/kmyk[P]codevs-for-student-2016/Main.cpp
// Function: primitive::is_valid_output(primitive::blocks_t<16ul, 10ul> const&, primitive::blocks_t<3ul, 3ul> const&, primitive::output_t const&)
bool is_valid_output(field_t const & field, pack_t const & a_pack, output_t const & output) {
        if (0 <= output.x and output.x + pack_size <= width) return true;
        pack_t pack = rotate(a_pack, output.rotate); // お邪魔ブロックは既に置かれているとする
        repeat (dy, pack_size) repeat (dx, pack_size) if (pack.at[dx][dy] != empty_block) {
            int x = output.x + dx;
            if (x < 0 or width <= x) return false;
        }
        return true;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl (%rdx), %ebx
movb $0x1, %al
cmpl $0x8, %ebx
jae 0x2997
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
movq (%rsi), %rdi
movl 0x4(%rdx), %edx
movzbl 0x8(%rsi), %esi
callq 0x279c
movq %rsp, %rcx
movq %rax, (%rcx)
movb %dl, 0x8(%rcx)
xorl %edx, %edx
xorl %eax, %eax
movq $-0x9, %rsi
movl %ebx, %edi
cmpb $0x0, 0x9(%rcx,%rsi)
sete %r8b
cmpl $0xa, %edi
setb %r9b
orb %r8b, %r9b
je 0x298f
incl %edi
addq $0x3, %rsi
jne 0x29bc
cmpq $0x2, %rdx
leaq 0x1(%rdx), %rsi
setae %al
incq %rcx
movq %rsi, %rdx
cmpq $0x3, %rsi
jne 0x29b3
movb $0x1, %al
jmp 0x298f