LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]DKR-Decompressor/DKRGzip.c
// Function: rsync_roll(unsigned int, unsigned int)
void rsync_roll(u32 start, u32 num) {
    unsigned i;

    if (start < RSYNC_WIN) {
        /* before window fills. */
        for (i = start; i < RSYNC_WIN; i++) {
            if (i == start + num) return;
            rsync_sum += (u32)window[i];
        }
        num -= (RSYNC_WIN - start);
        start = RSYNC_WIN;
    }

    /* buffer after window full */
    for (i = start; i < start+num; i++) {
        /* New character in */
        rsync_sum += (u32)window[i];
        /* Old character out */
        rsync_sum -= (u32)window[i - RSYNC_WIN];
        if (rsync_chunk_end == 0xFFFFFFFF && RSYNC_SUM_MATCH(rsync_sum)) {
            rsync_chunk_end = i;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x1000, -0x4(%rbp)     # imm = 0x1000
jae 0xa832
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1000, -0xc(%rbp)     # imm = 0x1000
jae 0xa81b
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jne 0xa7f4
jmp 0xa8b5
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x10093a0(%rip), %rax   # 0x1013ba0
movzbl (%rax,%rcx), %eax
addl 0x641e(%rip), %eax      # 0x10c28
movl %eax, 0x6418(%rip)      # 0x10c28
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa7d9
movl $0x1000, %ecx           # imm = 0x1000
subl -0x4(%rbp), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl $0x1000, -0x4(%rbp)     # imm = 0x1000
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jae 0xa8b5
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x100934f(%rip), %rax   # 0x1013ba0
movzbl (%rax,%rcx), %eax
addl 0x63cd(%rip), %eax      # 0x10c28
movl %eax, 0x63c7(%rip)      # 0x10c28
movl -0xc(%rbp), %eax
subl $0x1000, %eax           # imm = 0x1000
movl %eax, %eax
movl %eax, %ecx
leaq 0x100932c(%rip), %rax   # 0x1013ba0
movzbl (%rax,%rcx), %ecx
movl 0x63aa(%rip), %eax      # 0x10c28
subl %ecx, %eax
movl %eax, 0x63a2(%rip)      # 0x10c28
cmpl $-0x1, 0x639f(%rip)     # 0x10c2c
jne 0xa8a8
movl 0x6393(%rip), %eax      # 0x10c28
andl $0xfff, %eax            # imm = 0xFFF
cmpl $0x0, %eax
jne 0xa8a8
movl -0xc(%rbp), %eax
movl %eax, 0x6384(%rip)      # 0x10c2c
jmp 0xa8aa
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa838
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]DKR-Decompressor/DKRGzip.c
// Function: zip()
void zip() {
    u16 deflate_flags = 0;
    
    outcnt = 0;
    incnt = 0;
    
    put_byte(GZIP_MAGIC[0]);
    put_byte(GZIP_MAGIC[1]);
    put_byte(DEFATED);
    put_byte(0); // flags
    put_int(0); // Timestamp
    
    u32 crc = updcrc(NULL, 0);
    
    bi_init();
    ct_init();
    lm_init(&deflate_flags);
    
    put_byte(deflate_flags); /* extra flags */
    put_byte(0x03); /* OS identifier, 0x03 = Unix */
    
    deflate();
    
    put_int(crc);
    put_int(incnt); // was bytes_in
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw $0x0, -0x2(%rbp)
movl $0x0, 0x10087f8(%rip)   # 0x1013b70
movl $0x0, 0x1008802(%rip)   # 0x1013b84
movsbl 0xf29(%rip), %edi       # 0xc2b2
callq 0x88c0
movsbl 0xf1e(%rip), %edi       # 0xc2b3
callq 0x88c0
movl $0x8, %edi
callq 0x88c0
xorl %edi, %edi
callq 0x88c0
xorl %edi, %edi
callq 0x8960
xorl %eax, %eax
movl %eax, %edi
xorl %esi, %esi
callq 0x8a20
movl %eax, -0x8(%rbp)
callq 0xae40
callq 0xae60
leaq -0x2(%rbp), %rdi
callq 0xb1a0
movw -0x2(%rbp), %ax
movsbl %al, %edi
callq 0x88c0
movl $0x3, %edi
callq 0x88c0
callq 0xa8c0
movl -0x8(%rbp), %edi
callq 0x8960
movl 0x1008788(%rip), %edi   # 0x1013b84
callq 0x8960
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DavidSM64[P]DKR-Decompressor/DKRGzip.c
// Function: dkr_gzip_compress
unsigned char* dkr_gzip_compress(unsigned char* input, int inputSize, int gzipLevel, int* outputSize) {
    if(inputSize > OUTPUT_BUFFER_SIZE) {
        printf("rare_gzip Error: Input file is too large, make sure it is under %d MiB.\n", OUTPUT_BUFFER_SIZE / 1024 / 1024);
        return NULL;
    }
    
    if(level < 4) {
        printf("rare_gzip Error: Currently only compression levels 4 to 9 are supported.\n");
        return NULL;
    }
    
    inbuf = input;
    inbufSize = inputSize;
    level = gzipLevel;
    
    zip();
    
    *outputSize = outcnt;
    return outbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1000000, -0x14(%rbp) # imm = 0x1000000
jle 0xb44c
leaq 0xde9(%rip), %rdi       # 0xc21f
movl $0x10, %esi
movb $0x0, %al
callq 0x2050
movq $0x0, -0x8(%rbp)
jmp 0xb4a6
cmpl $0x4, 0x578d(%rip)      # 0x10be0
jge 0xb46d
leaq 0xe0c(%rip), %rdi       # 0xc268
movb $0x0, %al
callq 0x2050
movq $0x0, -0x8(%rbp)
jmp 0xb4a6
movq -0x10(%rbp), %rax
movq %rax, 0x1008700(%rip)   # 0x1013b78
movl -0x14(%rbp), %eax
movl %eax, 0x10086ff(%rip)   # 0x1013b80
movl -0x18(%rbp), %eax
movl %eax, 0x5756(%rip)      # 0x10be0
callq 0xb360
movl 0x10086db(%rip), %ecx   # 0x1013b70
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
leaq 0x86ce(%rip), %rax      # 0x13b70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: print_test_summary
void print_test_summary(size_t tgt_tests, size_t passed, double elapsed) {
    elapsed = (elapsed / 1e3);
    if (tgt_tests == passed) {
        (void)printf(SIR_EOL SIR_WHITEB("done: ")
            SIR_GREENB("%s%zu " SIR_ULINE("libsir") " %s " SIR_EMPH("passed") " in %.03fsec!")
            SIR_EOL SIR_EOL, tgt_tests > 1 ? "all " : "", tgt_tests, TEST_S(tgt_tests), elapsed);
    } else {
        (void)printf(SIR_EOL SIR_WHITEB("done: ")
            SIR_REDB("%zu of %zu " SIR_ULINE("libsir") " %s " SIR_EMPH("failed") " in %.03fsec")
            SIR_EOL SIR_EOL, tgt_tests - passed, tgt_tests, TEST_S(tgt_tests), elapsed);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd 0x187f8(%rip), %xmm1    # 0x1d008
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x4875
movq 0x10(%rsp), %rcx
leaq 0x18a96(%rip), %rsi     # 0x1d2c7
leaq 0x18917(%rip), %rax     # 0x1d14f
cmpq $0x1, %rcx
cmovaq %rax, %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rdi
leaq 0x1c0f3(%rip), %rcx     # 0x20944
leaq 0x1adb5(%rip), %rax     # 0x1f60d
cmpq $0x1, %rdi
cmovaq %rax, %rcx
movsd (%rsp), %xmm0
leaq 0x1887c(%rip), %rdi     # 0x1d0e8
movb $0x1, %al
callq 0x4180
jmp 0x48b2
movq 0x10(%rsp), %rsi
subq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rdi
leaq 0x1c0b4(%rip), %rcx     # 0x20944
leaq 0x1ad76(%rip), %rax     # 0x1f60d
cmpq $0x1, %rdi
cmovaq %rax, %rcx
movsd (%rsp), %xmm0
leaq 0x188a9(%rip), %rdi     # 0x1d154
movb $0x1, %al
callq 0x4180
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: mark_test_to_run
bool mark_test_to_run(const char* const name, sir_test* tests, size_t num_tests) {
    bool found = false;
    for (size_t t = 0; t < num_tests; t++) {
        if (_sir_strsame(name, tests[t].name, strnlen(name, SIR_MAXTESTNAME))) {
            found = tests[t].run = true;
            break;
        }
    }
    return found;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x49cd
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl $0x20, %esi
callq 0x4230
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x49e0
testb $0x1, %al
jne 0x49a2
jmp 0x49bb
movq 0x28(%rsp), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movb $0x1, 0x10(%rax)
movb $0x1, 0x1f(%rsp)
jmp 0x49cd
jmp 0x49bd
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4951
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: print_test_list
void print_test_list(const sir_test* tests, size_t num_tests) {
    static const size_t tab_size = 4;

    size_t longest = 0;
    for (size_t i = 0; i < num_tests; i++) {
        size_t len = strnlen(tests[i].name, SIR_MAXTESTNAME);
        if (len > longest)
            longest = len;
    }

    (void)printf(SIR_EOL SIR_WHITE("Available tests:") SIR_EOL SIR_EOL);

    for (size_t i = 0; i < num_tests; i++) {
        (void)printf("\t%s", tests[i].name);

        size_t len = strnlen(tests[i].name, SIR_MAXTESTNAME);
        if (len < longest + tab_size) {
            for (size_t n = len; n < longest + tab_size; n++)
                (void)printf(" ");
        }

        if ((i % 2) != 0 || i == num_tests - 1)
            (void)printf(SIR_EOL);
    }

    (void)printf(SIR_EOL);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x4a94
movq 0x40(%rsp), %rax
imulq $0x18, 0x28(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x4230
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x4a82
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x4a84
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x4a40
leaq 0x18764(%rip), %rdi     # 0x1d1ff
movb $0x0, %al
callq 0x4180
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x4b8f
movq 0x40(%rsp), %rax
imulq $0x18, 0x18(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x18754(%rip), %rdi     # 0x1d227
movb $0x0, %al
callq 0x4180
movq 0x40(%rsp), %rax
imulq $0x18, 0x18(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x4230
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
addq $0x4, %rcx
cmpq %rcx, %rax
jae 0x4b4a
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
addq $0x4, %rcx
cmpq %rcx, %rax
jae 0x4b48
leaq 0x1d4cc(%rip), %rdi     # 0x21ffd
movb $0x0, %al
callq 0x4180
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4b17
jmp 0x4b4a
movq 0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x4b6c
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4b7a
leaq 0x18753(%rip), %rdi     # 0x1d2c6
movb $0x0, %al
callq 0x4180
jmp 0x4b7c
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4aab
leaq 0x18730(%rip), %rdi     # 0x1d2c6
movb $0x0, %al
callq 0x4180
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: print_test_error
bool print_test_error(bool result, bool expected) {
    char msg[SIR_MAXERROR] = {0};
    uint16_t code          = sir_geterror(msg);
    if (SIR_E_NOERROR != code) {
        if (!expected && !result)
            TEST_MSG(SIR_RED("!! Unexpected (%" PRIu16 ", %s)"), code, msg);
        else if (expected)
            TEST_MSG(SIR_GREEN("Expected (%" PRIu16 ", %s)"), code, msg);
    }
    return result;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movb %sil, %al
movb %dil, %cl
andb $0x1, %cl
movb %cl, 0x117(%rsp)
andb $0x1, %al
movb %al, 0x116(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x4210
leaq 0x10(%rsp), %rdi
callq 0xf5a0
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x4e42
testb $0x1, 0x116(%rsp)
jne 0x4e1c
testb $0x1, 0x117(%rsp)
jne 0x4e1c
movzwl 0xe(%rsp), %esi
leaq 0x10(%rsp), %rdx
leaq 0x18445(%rip), %rdi     # 0x1d258
movb $0x0, %al
callq 0x4180
jmp 0x4e40
testb $0x1, 0x116(%rsp)
je 0x4e3e
movzwl 0xe(%rsp), %esi
leaq 0x10(%rsp), %rdx
leaq 0x1844e(%rip), %rdi     # 0x1d285
movb $0x0, %al
callq 0x4180
jmp 0x4e40
jmp 0x4e42
movb 0x117(%rsp), %al
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: find_cl_arg
const sir_cl_arg* find_cl_arg(const char* flag, const sir_cl_arg* args, size_t num_args) {
    for (size_t n = 0; n < num_args; n++) {
        const sir_cl_arg* arg = &args[n];
        if (_sir_strsame(flag, arg->flag, strnlen(arg->flag, SIR_CL_MAXFLAG)))
            return arg;
    }
    return NULL;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x4f3a
movq 0x30(%rsp), %rax
imulq $0x18, 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x4230
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x49e0
testb $0x1, %al
jne 0x4f1c
jmp 0x4f28
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4f43
jmp 0x4f2a
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4ebc
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: wait_for_keypress
void wait_for_keypress(void) {
    (void)printf(SIR_WHITEB(SIR_EMPH("press any key to exit...")) SIR_EOL);
    char ch = '\0';
    (void)_sir_getchar(&ch);
    SIR_UNUSED(ch);
}

// Assembly:
pushq %rax
leaq 0x1802f(%rip), %rdi     # 0x1d3b7
movb $0x0, %al
callq 0x4180
movb $0x0, 0x7(%rsp)
leaq 0x7(%rsp), %rdi
callq 0x15420
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: sir_sleep_msec
void sir_sleep_msec(uint32_t msec) {
    if (0U == msec)
        return;

#if !defined(__WIN__)
    struct timespec ts = { msec / 1000, (msec % 1000) * 1000000 };
    (void)nanosleep(&ts, NULL);
#else /* __WIN__ */
    (void)SleepEx((DWORD)msec, TRUE);
#endif
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
xorl %eax, %eax
cmpl 0x14(%rsp), %eax
jne 0x53f2
jmp 0x542b
movl 0x14(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rsp, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x41d0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: sir_readline
size_t sir_readline(FILE* f, char* buf, size_t size) {
    if (!f || !buf || 0 == size)
        return 0;

    size_t idx = 0;

    while (idx < size) {
        int ch = getc(f);
        if (EOF == ch || '\r' == ch || '\n' == ch)
            break;
        buf[idx++] = (char)ch;
    }

    return (0 == ferror(f)) ? idx : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x545c
cmpq $0x0, 0x20(%rsp)
je 0x545c
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
jne 0x546a
movq $0x0, 0x30(%rsp)
jmp 0x54ff
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x54d1
movq 0x28(%rsp), %rdi
callq 0x4590
movl %eax, 0xc(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0xc(%rsp), %eax
je 0x54ae
movl $0xd, %eax
cmpl 0xc(%rsp), %eax
je 0x54ae
movl $0xa, %eax
cmpl 0xc(%rsp), %eax
jne 0x54b0
jmp 0x54d1
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rsp)
movb %dl, (%rax,%rcx)
jmp 0x5473
movq 0x28(%rsp), %rdi
callq 0x40d0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x54ee
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x54f6
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x54f6
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: rmfile
void rmfile(const char* filename, bool leave_logs) {
    /* skip if leave_logs is true. */
    if (leave_logs) {
        TEST_MSG(SIR_WHITE("skipping deletion of '%s' (%s)"), filename, SIR_CL_LEAVELOGSFLAG);
        return;
    }

    struct stat st;
    if (0 != stat(filename, &st)) {
        /* ignore errors if the file doesn't exist. */
        if (ENOENT == errno)
            return;
        HANDLE_OS_ERROR(true, "failed to stat %s!", filename);
        return;
    }

    if (!_sir_deletefile(filename))
        HANDLE_OS_ERROR(false, "failed to delete %s!", filename);
    else
        TEST_MSG(SIR_DGRAY("deleted %s (%ld bytes)"), filename, (long)st.st_size);
}

// Assembly:
subq $0xa8, %rsp
movb %sil, %al
movq %rdi, 0xa0(%rsp)
andb $0x1, %al
movb %al, 0x9f(%rsp)
testb $0x1, 0x9f(%rsp)
je 0x5577
movq 0xa0(%rsp), %rsi
leaq 0x17e8a(%rip), %rdi     # 0x1d3ee
leaq 0x17e27(%rip), %rdx     # 0x1d392
movb $0x0, %al
callq 0x4180
jmp 0x5657
movq 0xa0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4310
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x55e9
callq 0x4070
movq %rax, %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
jne 0x55a7
jmp 0x5657
jmp 0x55a9
callq 0x4070
movl (%rax), %edi
leaq 0x17e6c(%rip), %rsi     # 0x1d423
leaq 0x17d5d(%rip), %rdx     # 0x1d31b
movl $0x133, %ecx            # imm = 0x133
callq 0x10780
movq 0xa0(%rsp), %rsi
leaq 0x17e53(%rip), %rdi     # 0x1d42a
movb $0x0, %al
callq 0x4180
xorl %esi, %esi
movl %esi, %edi
callq 0x4da0
jmp 0x5657
movq 0xa0(%rsp), %rdi
callq 0x143f0
testb $0x1, %al
jne 0x563c
jmp 0x55fc
callq 0x4070
movl (%rax), %edi
leaq 0x17e19(%rip), %rsi     # 0x1d423
leaq 0x17d0a(%rip), %rdx     # 0x1d31b
movl $0x138, %ecx            # imm = 0x138
callq 0x10780
movq 0xa0(%rsp), %rsi
leaq 0x17e2a(%rip), %rdi     # 0x1d454
movb $0x0, %al
callq 0x4180
xorl %esi, %esi
movl %esi, %edi
callq 0x4da0
jmp 0x5657
movq 0xa0(%rsp), %rsi
movq 0x38(%rsp), %rdx
leaq 0x17e30(%rip), %rdi     # 0x1d480
movb $0x0, %al
callq 0x4180
addq $0xa8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests_shared.c
// Function: enumfiles
bool enumfiles(const char* path, const char* search, bool del, unsigned* count) {
#if !defined(__WIN__)
    DIR* d = opendir(path);
    if (!d)
        return print_test_error(false, false);

    rewinddir(d);
    const struct dirent* di = readdir(d);
    if (!di) {
        (void)closedir(d);
        return print_test_error(false, false);
    }

    while (NULL != di) {
        if (strstr(di->d_name, search)) {
            if (del) {
                char filepath[SIR_MAXPATH];
                _sir_snprintf_trunc(filepath, SIR_MAXPATH, "%s%s", path, di->d_name);
                rmfile(filepath, false);
            }
            (*count)++;
        }
        di = readdir(d);
    }

    (void)closedir(d);
    d = NULL;
#else /* __WIN__ */
    WIN32_FIND_DATA finddata = {0};
    char buf[SIR_MAXPATH]    = {0};

    (void)snprintf(buf, SIR_MAXPATH, "%s/*", path);

    HANDLE enumerator = FindFirstFile(buf, &finddata);
    if (INVALID_HANDLE_VALUE == enumerator)
        return false;

    do {
        if (strstr(finddata.cFileName, search)) {
            if (del) {
                char filepath[SIR_MAXPATH];
                _sir_snprintf_trunc(filepath, SIR_MAXPATH, "%s%s", path, finddata.cFileName);
                rmfile(filepath, false);
            }
            (*count)++;
        }
    } while (FindNextFile(enumerator, &finddata) > 0);

    FindClose(enumerator);
    enumerator = NULL;
#endif
    return true;
}

// Assembly:
subq $0x1048, %rsp           # imm = 0x1048
movb %dl, %al
movq %rdi, 0x1038(%rsp)
movq %rsi, 0x1030(%rsp)
andb $0x1, %al
movb %al, 0x102f(%rsp)
movq %rcx, 0x1020(%rsp)
movq 0x1038(%rsp), %rdi
callq 0x4150
movq %rax, 0x1018(%rsp)
cmpq $0x0, 0x1018(%rsp)
jne 0x56c1
xorl %esi, %esi
movl %esi, %edi
callq 0x4da0
andb $0x1, %al
movb %al, 0x1047(%rsp)
jmp 0x57e6
movq 0x1018(%rsp), %rdi
callq 0x4250
movq 0x1018(%rsp), %rdi
callq 0x43a0
movq %rax, 0x1010(%rsp)
cmpq $0x0, 0x1010(%rsp)
jne 0x5712
movq 0x1018(%rsp), %rdi
callq 0x4260
xorl %esi, %esi
movl %esi, %edi
callq 0x4da0
andb $0x1, %al
movb %al, 0x1047(%rsp)
jmp 0x57e6
jmp 0x5714
xorl %eax, %eax
cmpq 0x1010(%rsp), %rax
je 0x57c5
movq 0x1010(%rsp), %rdi
addq $0x13, %rdi
movq 0x1030(%rsp), %rsi
callq 0x45a0
cmpq $0x0, %rax
je 0x57ab
testb $0x1, 0x102f(%rsp)
je 0x579c
jmp 0x574f
movq $0x1000, 0x8(%rsp)      # imm = 0x1000
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x1038(%rsp), %rcx
movq 0x1010(%rsp), %r8
addq $0x13, %r8
leaq 0x19a37(%rip), %rdx     # 0x1f1b4
movb $0x0, %al
callq 0x41b0
cmpl $0x0, %eax
jne 0x578e
movq 0x8(%rsp), %rax
jmp 0x5790
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x5530
movq 0x1020(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x1018(%rsp), %rdi
callq 0x43a0
movq %rax, 0x1010(%rsp)
jmp 0x5714
movq 0x1018(%rsp), %rdi
callq 0x4260
movq $0x0, 0x1018(%rsp)
movb $0x1, 0x1047(%rsp)
movb 0x1047(%rsp), %al
andb $0x1, %al
addq $0x1048, %rsp           # imm = 0x1048
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_exceedmaxsize
bool sirtest_exceedmaxsize(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    char toobig[SIR_MAXMESSAGE + 100] = {0};
    (void)memset(toobig, 'a', SIR_MAXMESSAGE + 100);
    toobig[SIR_MAXMESSAGE + 99] = '\0';

    _sir_eqland(pass, sir_info("%s", toobig));

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x1188, %rsp           # imm = 0x1188
leaq 0x1080(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x1084(%rsp) # imm = 0x100000
movw $0xff, 0x1080(%rsp)
movl $0x100000, 0x108c(%rsp) # imm = 0x100000
movw $0x0, 0x1088(%rsp)
leaq 0x1770b(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x17952(%rip), %rdx     # 0x1d517
leaq 0x17961(%rip), %rcx     # 0x1d52d
movl $0xa3, %r8d
callq 0x5ce0
testb $0x1, %al
jne 0x5bdd
jmp 0x5c00
leaq 0x1080(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x176cf(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0x107f(%rsp)
leaq 0x1080(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0x107f(%rsp)
movb 0x107f(%rsp), %al
andb $0x1, %al
movb %al, 0x107e(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x1064, %edx           # imm = 0x1064
callq 0x4210
leaq 0x10(%rsp), %rdi
movl $0x61, %esi
movl $0x1064, %edx           # imm = 0x1064
callq 0x4210
movb $0x0, 0x1073(%rsp)
leaq 0x10(%rsp), %rsi
leaq 0x175c1(%rip), %rdi     # 0x1d228
movb $0x0, %al
callq 0xf770
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x5c7d
jmp 0x5c88
movb 0x107e(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x107e(%rsp)
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x5ca9
jmp 0x5cb4
movb 0x107e(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x107e(%rsp)
movb 0x107e(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x1188, %rsp           # imm = 0x1188
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failemptymessage
bool sirtest_failemptymessage(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    _sir_eqland(pass, !sir_debug("%s", ""));

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0xff, 0x10(%rsp)
movl $0x100000, 0x1c(%rsp)   # imm = 0x100000
movw $0x0, 0x18(%rsp)
leaq 0x1677a(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x16ee4(%rip), %rdx     # 0x1da3a
leaq 0x169d0(%rip), %rcx     # 0x1d52d
movl $0x17d, %r8d            # imm = 0x17D
callq 0x5ce0
testb $0x1, %al
jne 0x6b6e
jmp 0x6b8e
leaq 0x10(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x16741(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
leaq 0x16674(%rip), %rdi     # 0x1d228
leaq 0x1670c(%rip), %rsi     # 0x1d2c7
movb $0x0, %al
callq 0xf5f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xd(%rsp)
jne 0x6bd7
movb 0xe(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xc(%rsp)
jne 0x6bf5
jmp 0x6bfd
movb 0xe(%rsp), %al
movb %al, 0xc(%rsp)
movb 0xc(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failinvalidfilename
bool sirtest_failinvalidfilename(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    _sir_eqland(pass, 0U == sir_addfile("bad file!/name", SIRL_ALL, SIRO_MSGONLY));

    if (pass)
        PRINT_EXPECTED_ERROR();

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0xff, 0x10(%rsp)
movl $0x100000, 0x1c(%rsp)   # imm = 0x100000
movw $0x0, 0x18(%rsp)
leaq 0x160aa(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x168cc(%rip), %rdx     # 0x1daf2
leaq 0x16300(%rip), %rcx     # 0x1d52d
movl $0x1d1, %r8d            # imm = 0x1D1
callq 0x5ce0
testb $0x1, %al
jne 0x723e
jmp 0x725e
leaq 0x10(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x16071(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
leaq 0x1688a(%rip), %rdi     # 0x1db0e
movl $0xff, %esi
movl $0x7f00, %edx           # imm = 0x7F00
callq 0xfee0
movl %eax, %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, 0xd(%rsp)
jne 0x72a9
movb 0xe(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
testb $0x1, 0xe(%rsp)
je 0x72c6
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xc(%rsp)
jne 0x72da
jmp 0x72e2
movb 0xe(%rsp), %al
movb %al, 0xc(%rsp)
movb 0xc(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failfilebadpermission
bool sirtest_failfilebadpermission(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

#if !defined(__WIN__)
    static const char* path = "/noperms";
#else /* __WIN__ */
# if defined(__CYGWIN__)
    static const char* path = "/cygdrive/c/Windows/System32/noperms";
# else
    static const char* path;
    if (get_wineversion()) {
        path = "Z:\\noperms";
    } else {
        path = "C:\\Windows\\System32\\noperms";
    }
# endif
#endif

    _sir_eqland(pass, 0U == sir_addfile(path, SIRL_ALL, SIRO_MSGONLY));

    if (pass)
        PRINT_EXPECTED_ERROR();

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0xff, 0x10(%rsp)
movl $0x100000, 0x1c(%rsp)   # imm = 0x100000
movw $0x0, 0x18(%rsp)
leaq 0x15f7a(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x167c7(%rip), %rdx     # 0x1db1d
leaq 0x161d0(%rip), %rcx     # 0x1d52d
movl $0x1de, %r8d            # imm = 0x1DE
callq 0x5ce0
testb $0x1, %al
jne 0x736e
jmp 0x738e
leaq 0x10(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x15f41(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movq 0x212ec(%rip), %rdi     # 0x286a0
movl $0xff, %esi
movl $0x7f00, %edx           # imm = 0x7F00
callq 0xfee0
movl %eax, %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, 0xd(%rsp)
jne 0x73d9
movb 0xe(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
testb $0x1, 0xe(%rsp)
je 0x73f6
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xc(%rsp)
jne 0x740a
jmp 0x7412
movb 0xe(%rsp), %al
movb %al, 0xc(%rsp)
movb 0xc(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failremovebadfile
bool sirtest_failremovebadfile(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    sirfileid invalidid = 9999999;
    _sir_eqland(pass, !sir_remfile(invalidid));

    if (pass)
        PRINT_EXPECTED_ERROR();

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0xff, 0x10(%rsp)
movl $0x100000, 0x1c(%rsp)   # imm = 0x100000
movw $0x0, 0x18(%rsp)
leaq 0x15ada(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x16401(%rip), %rdx     # 0x1dbf7
leaq 0x15d30(%rip), %rcx     # 0x1d52d
movl $0x23f, %r8d            # imm = 0x23F
callq 0x5ce0
testb $0x1, %al
jne 0x780e
jmp 0x782e
leaq 0x10(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x15aa1(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movl $0x98967f, 0x8(%rsp)    # imm = 0x98967F
movl 0x8(%rsp), %edi
callq 0xff10
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x7873
movb 0xe(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
testb $0x1, 0xe(%rsp)
je 0x7890
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x78a4
jmp 0x78ac
movb 0xe(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_rollandarchivefile
bool sirtest_rollandarchivefile(void) {
    bool pass = true;

    _sir_eqland(pass, roll_and_archive("rollandarchive1", ".log"));
    _sir_eqland(pass, roll_and_archive("rollandarchive2", ""));

    return pass;
}

// Assembly:
pushq %rax
movb $0x1, 0x7(%rsp)
leaq 0x16334(%rip), %rdi     # 0x1dc11
leaq 0x16288(%rip), %rsi     # 0x1db6c
callq 0x7950
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x78f8
jmp 0x7900
movb 0x7(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0x7(%rsp)
leaq 0x16310(%rip), %rdi     # 0x1dc21
leaq 0x159af(%rip), %rsi     # 0x1d2c7
callq 0x7950
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x5(%rsp)
jne 0x792c
jmp 0x7934
movb 0x7(%rsp), %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
andb $0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failwithoutinit
bool sirtest_failwithoutinit(void) {
    bool pass = !sir_info("sir isn't initialized; this needs to fail");

    if (pass)
        PRINT_EXPECTED_ERROR();

    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
pushq %rax
leaq 0x15ce9(%rip), %rdi     # 0x1dc31
movb $0x0, %al
callq 0xf770
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x7(%rsp)
testb $0x1, 0x7(%rsp)
je 0x7f6a
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
movb 0x7(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_isinitialized
bool sirtest_isinitialized(void) {

    bool pass = true;

    TEST_MSG_0("checking sir_isinitialized before initialization...");
    _sir_eqland(pass, !sir_isinitialized());

    INIT(si, SIRL_ALL, 0, 0, 0);
    _sir_eqland(pass, si_init);

    TEST_MSG_0("checking sir_isinitialized after initialization...");
    _sir_eqland(pass, sir_isinitialized());

    _sir_eqland(pass, sir_cleanup());

    TEST_MSG_0("checking sir_isinitialized after cleanup...");
    _sir_eqland(pass, !sir_isinitialized());

    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movb $0x1, 0x117(%rsp)
leaq 0x15cc5(%rip), %rdi     # 0x1dc5b
movb $0x0, %al
callq 0x4180
callq 0xf590
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x7fba
movb 0x117(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0xc(%rsp)    # imm = 0x100000
movw $0xff, 0x8(%rsp)
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0x0, 0x10(%rsp)
leaq 0x152ca(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x15c8b(%rip), %rdx     # 0x1dc91
leaq 0x15520(%rip), %rcx     # 0x1d52d
movl $0x265, %r8d            # imm = 0x265
callq 0x5ce0
testb $0x1, %al
jne 0x801e
jmp 0x803e
leaq 0x8(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x15291(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0x7(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0x7(%rsp)
xorl %eax, %eax
testb $0x1, 0x7(%rsp)
movb %al, 0x5(%rsp)
je 0x806b
movb 0x117(%rsp), %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
leaq 0x15c28(%rip), %rdi     # 0x1dca7
movb $0x0, %al
callq 0x4180
callq 0xf590
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x4(%rsp)
jne 0x809a
jmp 0x80a5
movb 0x117(%rsp), %al
movb %al, 0x4(%rsp)
movb 0x4(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x3(%rsp)
jne 0x80c6
jmp 0x80d1
movb 0x117(%rsp), %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
leaq 0x15bf7(%rip), %rdi     # 0x1dcdc
movb $0x0, %al
callq 0x4180
callq 0xf590
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x2(%rsp)
jne 0x8109
movb 0x117(%rsp), %al
movb %al, 0x2(%rsp)
movb 0x2(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
movb 0x117(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failinittwice
bool sirtest_failinittwice(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    INIT(si2, SIRL_ALL, 0, 0, 0);
    _sir_eqland(pass, !si2_init);

    if (pass)
        PRINT_EXPECTED_ERROR();

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
leaq 0x120(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x124(%rsp) # imm = 0x100000
movw $0xff, 0x120(%rsp)
movl $0x100000, 0x12c(%rsp) # imm = 0x100000
movw $0x0, 0x128(%rsp)
leaq 0x1513b(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x15b75(%rip), %rdx     # 0x1dd0a
leaq 0x15391(%rip), %rcx     # 0x1d52d
movl $0x274, %r8d            # imm = 0x274
callq 0x5ce0
testb $0x1, %al
jne 0x81ad
jmp 0x81d0
leaq 0x120(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x150ff(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0x11f(%rsp)
leaq 0x120(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0x11f(%rsp)
movb 0x11f(%rsp), %al
andb $0x1, %al
movb %al, 0x11e(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0xff, 0x10(%rsp)
movl $0x100000, 0x1c(%rsp)   # imm = 0x100000
movw $0x0, 0x18(%rsp)
leaq 0x15093(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x15acd(%rip), %rdx     # 0x1dd0a
leaq 0x152e9(%rip), %rcx     # 0x1d52d
movl $0x277, %r8d            # imm = 0x277
callq 0x5ce0
testb $0x1, %al
jne 0x8255
jmp 0x8275
leaq 0x10(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x1505a(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0xf(%rsp)
xorl %eax, %eax
testb $0x1, 0xf(%rsp)
movb %al, 0xe(%rsp)
jne 0x82a2
movb 0x11e(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x11e(%rsp)
testb $0x1, 0x11e(%rsp)
je 0x82c5
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xd(%rsp)
jne 0x82d9
jmp 0x82e4
movb 0x11e(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0x11e(%rsp)
movb 0x11e(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x228, %rsp            # imm = 0x228
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failinvalidinitdata
bool sirtest_failinvalidinitdata(void) {
    sirinit si;

    /* fill with bad data. */
    (void)memset(&si, 0xab, sizeof(sirinit));

    TEST_MSG_0("calling sir_init with invalid data...");
    bool pass = !sir_init(&si);

    if (pass)
        PRINT_EXPECTED_ERROR();

    (void)sir_cleanup();
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0x10(%rsp), %rdi
movl $0xab, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
leaq 0x159ee(%rip), %rdi     # 0x1dd20
movb $0x0, %al
callq 0x4180
leaq 0x10(%rsp), %rdi
callq 0xf560
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
je 0x835e
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
callq 0xf580
movb 0xf(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_initmakeinit
bool sirtest_initmakeinit(void) {
    bool pass = true;

    sirinit si;
    _sir_eqland(pass, sir_makeinit(&si));
    _sir_eqland(pass, sir_init(&si));
    _sir_eqland(pass, sir_info("initialized with sir_makeinit"));
    _sir_eqland(pass, sir_cleanup());

    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movb $0x1, 0x117(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf540
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x85f8
jmp 0x8603
movb 0x117(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
leaq 0x8(%rsp), %rdi
callq 0xf560
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x8629
jmp 0x8634
movb 0x117(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
leaq 0x1576f(%rip), %rdi     # 0x1ddb7
movb $0x0, %al
callq 0xf770
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x5(%rsp)
jne 0x865e
jmp 0x8669
movb 0x117(%rsp), %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x4(%rsp)
jne 0x868a
jmp 0x8695
movb 0x117(%rsp), %al
movb %al, 0x4(%rsp)
movb 0x4(%rsp), %al
andb $0x1, %al
movb %al, 0x117(%rsp)
movb 0x117(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_failaftercleanup
bool sirtest_failaftercleanup(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    _sir_eqland(pass, sir_cleanup());
    _sir_eqland(pass, !sir_info("already cleaned up; this needs to fail"));

    if (pass)
        PRINT_EXPECTED_ERROR();

    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x14(%rsp)   # imm = 0x100000
movw $0xff, 0x10(%rsp)
movl $0x100000, 0x1c(%rsp)   # imm = 0x100000
movw $0x0, 0x18(%rsp)
leaq 0x14bca(%rip), %rdi     # 0x1d2c7
xorl %esi, %esi
leaq 0x156cf(%rip), %rdx     # 0x1ddd5
leaq 0x14e20(%rip), %rcx     # 0x1d52d
movl $0x2ae, %r8d            # imm = 0x2AE
callq 0x5ce0
testb $0x1, %al
jne 0x871e
jmp 0x873e
leaq 0x10(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0x14b91(%rip), %rdx     # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xd(%rsp)
jne 0x8771
jmp 0x8779
movb 0xe(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
leaq 0x15664(%rip), %rdi     # 0x1ddee
movb $0x0, %al
callq 0xf770
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xc(%rsp)
jne 0x87a6
movb 0xe(%rsp), %al
movb %al, 0xc(%rsp)
movb 0xc(%rsp), %al
andb $0x1, %al
movb %al, 0xe(%rsp)
testb $0x1, 0xe(%rsp)
je 0x87c3
movl $0x1, %esi
movl %esi, %edi
callq 0x4da0
movb 0xe(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x118, %rsp            # imm = 0x118
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: filter_error
bool filter_error(bool pass, uint16_t err) {
    if (!pass) {
        char msg[SIR_MAXERROR] = {0};
        if (sir_geterror(msg) != err)
            return false;
    }
    return true;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movw %si, %ax
movb %dil, %cl
andb $0x1, %cl
movb %cl, 0x106(%rsp)
movw %ax, 0x104(%rsp)
testb $0x1, 0x106(%rsp)
jne 0xc12b
movq %rsp, %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x4210
movq %rsp, %rdi
callq 0xf5a0
movzwl %ax, %eax
movzwl 0x104(%rsp), %ecx
cmpl %ecx, %eax
je 0xc129
movb $0x0, 0x107(%rsp)
jmp 0xc133
jmp 0xc12b
movb $0x1, 0x107(%rsp)
movb 0x107(%rsp), %al
andb $0x1, %al
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_getcpucount
bool sirtest_getcpucount(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    TEST_MSG_0("checking processor counting function...");

    const long cpus = _sir_nprocs_test();
    _sir_eqland(pass, 0 < cpus);

    TEST_MSG("processor(s) detected: %ld", cpus);

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x24(%rsp)   # imm = 0x100000
movw $0xff, 0x20(%rsp)
movl $0x100000, 0x2c(%rsp)   # imm = 0x100000
movw $0x0, 0x28(%rsp)
leaq 0xeb9a(%rip), %rdi      # 0x1d2c7
xorl %esi, %esi
leaq 0x11cf7(%rip), %rdx     # 0x2042d
leaq 0xedf0(%rip), %rcx      # 0x1d52d
movl $0x838, %r8d            # imm = 0x838
callq 0x5ce0
testb $0x1, %al
jne 0xe74e
jmp 0xe76e
leaq 0x20(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0xeb61(%rip), %rdx      # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0x1f(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x1e(%rsp)
leaq 0x11cad(%rip), %rdi     # 0x20441
movb $0x0, %al
callq 0x4180
movl $0x1, %edi
callq 0x193c0
movq %rax, 0x10(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq 0x10(%rsp), %rcx
movb %al, 0xf(%rsp)
jge 0xe7c1
movb 0x1e(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x1e(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x11c94(%rip), %rdi     # 0x2046b
movb $0x0, %al
callq 0x4180
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xe7f2
jmp 0xe7fa
movb 0x1e(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x1e(%rsp)
movb 0x1e(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x128, %rsp            # imm = 0x128
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aremmell[P]libsir/tests/tests.c
// Function: sirtest_getversioninfo
bool sirtest_getversioninfo(void) {
    INIT(si, SIRL_ALL, 0, 0, 0);
    bool pass = si_init;

    TEST_MSG_0("checking version retrieval functions...");

    const char* str = sir_getversionstring();
    _sir_eqland(pass, _sir_validstrnofail(str));

    TEST_MSG("version as string: '%s'", _SIR_PRNSTR(str));

    uint32_t hex = sir_getversionhex();
    _sir_eqland(pass, 0 != hex);

    TEST_MSG("version as hex: 0x%08"PRIx32"", hex);

    bool prerel = sir_isprerelease();
    TEST_MSG("prerelease: %s", prerel ? "true" : "false");

    _sir_eqland(pass, sir_cleanup());
    return PRINT_RESULT_RETURN(pass);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x108, %edx            # imm = 0x108
callq 0x4210
movl $0x100000, 0x34(%rsp)   # imm = 0x100000
movw $0xff, 0x30(%rsp)
movl $0x100000, 0x3c(%rsp)   # imm = 0x100000
movw $0x0, 0x38(%rsp)
leaq 0xea6a(%rip), %rdi      # 0x1d2c7
xorl %esi, %esi
leaq 0x11c22(%rip), %rdx     # 0x20488
leaq 0xecc0(%rip), %rcx      # 0x1d52d
movl $0x847, %r8d            # imm = 0x847
callq 0x5ce0
testb $0x1, %al
jne 0xe87e
jmp 0xe89e
leaq 0x30(%rsp), %rdi
addq $0xe8, %rdi
movl $0x20, %ecx
leaq 0xea31(%rip), %rdx      # 0x1d2c7
movq %rcx, %rsi
callq 0x14f50
movb $0x0, 0x2f(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xf560
andb $0x1, %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x2e(%rsp)
leaq 0x11bdb(%rip), %rdi     # 0x2049f
movb $0x0, %al
callq 0x4180
callq 0x10490
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %esi, %esi
leaq 0x11ba5(%rip), %rdx     # 0x20488
leaq 0xec43(%rip), %rcx      # 0x1d52d
movl $0x84d, %r8d            # imm = 0x84D
callq 0x5ce0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1a(%rsp)
jne 0xe904
jmp 0xe90c
movb 0x2e(%rsp), %al
movb %al, 0x1a(%rsp)
movb 0x1a(%rsp), %al
andb $0x1, %al
movb %al, 0x2e(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xe92a
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xe938
leaq 0x11bb2(%rip), %rax     # 0x204e3
movq %rax, 0x10(%rsp)
jmp 0xe938
movq 0x10(%rsp), %rsi
leaq 0x11b85(%rip), %rdi     # 0x204c9
movb $0x0, %al
callq 0x4180
callq 0x104a0
movl %eax, 0x1c(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl 0x1c(%rsp), %ecx
movb %al, 0xf(%rsp)
je 0xe96a
movb 0x2e(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x2e(%rsp)
movl 0x1c(%rsp), %esi
leaq 0x11b6b(%rip), %rdi     # 0x204ea
movb $0x0, %al
callq 0x4180
callq 0x104b0
andb $0x1, %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %cl
leaq 0x10f30(%rip), %rsi     # 0x1f8cc
leaq 0x10f24(%rip), %rax     # 0x1f8c7
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x11b52(%rip), %rdi     # 0x20503
movb $0x0, %al
callq 0x4180
callq 0xf580
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xe9cc
jmp 0xe9d4
movb 0x2e(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x2e(%rsp)
movb 0x2e(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edi
callq 0x4da0
andb $0x1, %al
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax,%rax)