LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: arg_size
static unsigned arg_size(const uint8_t *arg_mem, char type)
{
    if(!has_reserved(type))
        return 0;
    const uint8_t  *arg_pos=arg_mem;
    uint32_t blob_length = 0;
    switch(type)
    {
        case 'h':
        case 't':
        case 'd':
            return 8;
        case 'm':
        case 'r':
        case 'f':
        case 'c':
        case 'i':
            return 4;
        case 'S':
        case 's':
            while(*++arg_pos);
            arg_pos += 4-(arg_pos-arg_mem)%4;
            return arg_pos-arg_mem;
        case 'b':
            blob_length |= (*arg_pos++ << 24);
            blob_length |= (*arg_pos++ << 16);
            blob_length |= (*arg_pos++ << 8);
            blob_length |= (*arg_pos++);
            if(blob_length%4)
                blob_length += 4-blob_length%4;
            arg_pos += blob_length;
            return arg_pos-arg_mem;
        default:
            assert("Invalid Type");
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leal -0x53(%rsi), %ecx
cmpl $0x21, %ecx
ja 0x723f
movabsq $0x3846b8001, %rdx      # imm = 0x3846B8001
btq %rcx, %rdx
jae 0x723f
movsbl %sil, %ecx
leal -0x62(%rcx), %eax
cmpl $0x12, %eax
ja 0x71e8
leaq 0x285f(%rip), %rcx      # 0x9a30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %eax
jmp 0x723f
movl $0x8, %eax
jmp 0x723f
cmpl $0x53, %ecx
jne 0x7208
xorl %ecx, %ecx
cmpb $0x0, 0x1(%rdi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x71ef
leal 0x3(%rcx), %eax
testq %rcx, %rcx
cmovnsl %ecx, %eax
andl $-0x4, %eax
jmp 0x723c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x723f
movzbl (%rdi), %eax
shll $0x18, %eax
movzbl 0x1(%rdi), %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %edx
shll $0x8, %edx
orl %ecx, %edx
movzbl 0x3(%rdi), %ecx
orl %ecx, %edx
andl $0x3, %ecx
movl %edx, %eax
subl %ecx, %eax
addl $0x4, %eax
testl %ecx, %ecx
cmovel %edx, %eax
addl $0x4, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: bundle_ring_length
static size_t bundle_ring_length(ring_t *ring)
{
    unsigned pos = 8+8;//goto first length field
    uint32_t advance = 0;
    do {
        advance = deref(pos+0, ring) << (8*3) |
                  deref(pos+1, ring) << (8*2) |
                  deref(pos+2, ring) << (8*1) |
                  deref(pos+3, ring) << (8*0);
        if(advance)
            pos += 4+advance;
    } while(advance);

    return pos <= (ring[0].len+ring[1].len) ? pos : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
leaq 0x10(%rdi), %rax
movl $0x10, %esi
movl %esi, %edx
movq %rdx, %r10
movq %rdi, %r8
movq %rdx, %r9
subq %rcx, %r10
jb 0x7863
xorl %esi, %esi
movq %rax, %r8
movq %r10, %r9
cmpq 0x18(%rdi), %r10
jae 0x786e
movq (%r8), %rsi
movzbl (%rsi,%r9), %esi
shll $0x18, %esi
leal 0x1(%rdx), %r9d
movq %r9, %r11
movq %rdi, %r10
subq %rcx, %r11
jb 0x788c
xorl %r8d, %r8d
movq %rax, %r10
movq %r11, %r9
cmpq 0x18(%rdi), %r11
jae 0x7898
movq (%r10), %r8
movzbl (%r8,%r9), %r8d
shll $0x10, %r8d
leal 0x2(%rdx), %r10d
movq %r10, %rbx
movq %rdi, %r11
subq %rcx, %rbx
jb 0x78b6
xorl %r9d, %r9d
movq %rax, %r11
movq %rbx, %r10
cmpq 0x18(%rdi), %rbx
jae 0x78c2
movq (%r11), %r9
movzbl (%r9,%r10), %r9d
shll $0x8, %r9d
leal 0x3(%rdx), %r11d
movq %r11, %r14
movq %rdi, %rbx
subq %rcx, %r14
jb 0x78e0
xorl %r10d, %r10d
movq %rax, %rbx
movq %r14, %r11
cmpq 0x18(%rdi), %r14
jae 0x78e8
movq (%rbx), %r10
movzbl (%r10,%r11), %r10d
orl %esi, %r8d
orl %r8d, %r9d
movl %r9d, %r8d
orl %r10d, %r8d
leal 0x4(%r9,%r10), %esi
cmovel %r8d, %esi
addl %edx, %esi
testl %r8d, %r8d
jne 0x7845
movl %esi, %edx
addq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq %rdx, %rcx
cmovaeq %rdx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_valid_message_p
bool rtosc_valid_message_p(const char *msg, size_t len)
{
    //Validate Path Characters (assumes printable characters are sufficient)
    if(*msg != '/')
        return false;
    const char *tmp = msg;
    for(unsigned i=0; i<len; ++i) {
        if(*tmp == 0)
            break;
        if(!isprint(*tmp))
            return false;
        tmp++;
    }

    //tmp is now either pointing to a null or the end of the string
    const size_t offset1 = tmp-msg;
    size_t       offset2 = tmp-msg;
    for(; offset2<len; offset2++) {
        if(*tmp == ',')
            break;
        tmp++;
    }

    //Too many NULL bytes
    if(offset2-offset1 > 4)
        return false;

    if((offset2 % 4) != 0)
        return false;

    size_t observed_length = rtosc_message_length(msg, len);
    return observed_length == len;
}

// Assembly:
cmpb $0x2f, (%rdi)
jne 0x79f7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x799c
movl $0x1, %r12d
movq %r14, %r15
movsbq (%r15), %r13
testq %r13, %r13
je 0x799c
callq 0x22f0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r13,2)
je 0x79fa
incq %r15
movl %r12d, %eax
incl %r12d
cmpq %rbx, %rax
jb 0x7975
movq %r15, %rax
subq %r14, %rax
movq %rax, %rcx
cmpq %rbx, %rax
jae 0x79c1
movq %rax, %rcx
cmpb $0x2c, (%r15)
je 0x79c1
incq %r15
incq %rcx
cmpq %rbx, %rcx
jb 0x79ad
movq %rbx, %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x5, %rdx
setae %al
testb $0x3, %cl
setne %cl
orb %al, %cl
jne 0x79fa
leaq -0x50(%rbp), %rdi
movq %r14, (%rdi)
movq %rbx, 0x8(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
callq 0x7340
cmpq %rbx, %rax
sete %al
jmp 0x79fc
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_bundle
size_t rtosc_bundle(char *buffer, size_t len, uint64_t tt, int elms, ...)
{
    char *_buffer = buffer;
    memset(buffer, 0, len);
    strcpy(buffer, "#bundle");
    buffer += 8;
    emplace_uint64((uint8_t*)buffer, tt);
    buffer += 8;
    va_list va;
    va_start(va, elms);
    for(int i=0; i<elms; ++i) {
        const char   *msg  = va_arg(va, const char*);
        //It is assumed that any passed message/bundle is valid
        size_t        size = rtosc_message_length(msg, -1);
        emplace_uint32((uint8_t*)buffer, size);
        buffer += 4;
        memcpy(buffer, msg, size);
        buffer+=size;
    }
    va_end(va);

    return buffer-_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x120(%rbp), %r12
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x7a75
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
xorl %esi, %esi
callq 0x2140
movabsq $0x656c646e756223, %rax # imm = 0x656C646E756223
movq %rax, (%rbx)
movq %r15, %rcx
movq %r15, %rax
shrq $0x38, %rax
movb %al, 0x8(%rbx)
movq %r15, %rax
shrq $0x30, %rax
movb %al, 0x9(%rbx)
movq %r15, %rax
shrq $0x28, %rax
movb %al, 0xa(%rbx)
movq %r15, %rax
shrq $0x20, %rax
movb %al, 0xb(%rbx)
movl %ecx, %eax
shrl $0x18, %eax
movb %al, 0xc(%rbx)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xd(%rbx)
movb %ch, 0xe(%rbx)
movb %cl, 0xf(%rbx)
movq %rbx, -0x48(%rbp)
leaq 0x10(%rbx), %r15
movq %r12, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, -0x40(%rbp)
testl %r14d, %r14d
jle 0x7b5d
leaq -0x70(%rbp), %r12
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x7b0d
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x7b19
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rbx
movq %rbx, -0x70(%rbp)
movq $-0x1, -0x68(%rbp)
leaq -0x60(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %r12, %rdi
callq 0x7340
movq %rax, %r13
bswapl %eax
movl %eax, (%r15)
leaq 0x4(%r15), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x21e0
addq %r13, %r15
addq $0x4, %r15
decl %r14d
jne 0x7af5
subq -0x48(%rbp), %r15
movq %r15, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_bundle_elements
size_t rtosc_bundle_elements(const char *buffer, size_t len)
{
    const uint32_t *lengths = (const uint32_t*) (buffer+16);
    size_t elms = 0;
    while(POS < len && extract_uint32((const uint8_t*)lengths)) {
        lengths += extract_uint32((const uint8_t*)lengths)/4+1;

        if(POS > len)
            break;
        ++elms;
    }
    return elms;
}

// Assembly:
cmpq $0x11, %rsi
jb 0x7bad
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl (%rcx), %edx
bswapl %edx
testl %edx, %edx
je 0x7bab
andl $-0x4, %edx
addq %rdx, %rcx
addq $0x4, %rcx
movq %rcx, %rdx
subq %rdi, %rdx
cmpq %rsi, %rdx
ja 0x7bab
incq %rax
cmpq %rsi, %rdx
jb 0x7b86
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_bundle_fetch
const char *rtosc_bundle_fetch(const char *buffer, unsigned elm)
{
    const uint32_t *lengths = (const uint32_t*) (buffer+16);
    size_t elm_pos = 0;
    while(elm_pos!=elm && extract_uint32((const uint8_t*)lengths)) {
        ++elm_pos;
        lengths += extract_uint32((const uint8_t*)lengths)/4+1;
    }

    return (const char*) (elm==elm_pos?lengths+1:NULL);
}

// Assembly:
leaq 0x10(%rdi), %rcx
testl %esi, %esi
sete %dl
je 0x7be5
movl 0x10(%rdi), %eax
bswapl %eax
testl %eax, %eax
je 0x7be5
pushq %rbp
movq %rsp, %rbp
movl %esi, %esi
andl $-0x4, %eax
addq %rax, %rcx
addq $0x4, %rcx
decq %rsi
sete %dl
je 0x7be4
movl (%rcx), %eax
bswapl %eax
testl %eax, %eax
jne 0x7bca
popq %rbp
addq $0x4, %rcx
xorl %eax, %eax
testb %dl, %dl
cmovneq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_bundle_size
size_t rtosc_bundle_size(const char *buffer, unsigned elm)
{
    const uint32_t *lengths = (const uint32_t*) (buffer+16);
    size_t elm_pos = 0;
    size_t last_len = 0;
    while(elm_pos!=elm && extract_uint32((const uint8_t*)lengths)) {
        last_len = extract_uint32((const uint8_t*)lengths);
        ++elm_pos, lengths+=extract_uint32((const uint8_t*)lengths)/4+1;
    }

    return last_len;
}

// Assembly:
testl %esi, %esi
je 0x7c28
movl 0x10(%rdi), %ecx
bswapl %ecx
testl %ecx, %ecx
je 0x7c28
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
addq $0x10, %rdi
movl %ecx, %edx
decq %rax
je 0x7c24
movl %edx, %ecx
andl $-0x4, %ecx
addq %rcx, %rdi
addq $0x4, %rdi
movl (%rdi), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0x7c09
movl %edx, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_int_eq
int assert_int_eq(int a, int b, const char *testcase, int line)
{
    test_counter++;
    int err = a!=b;
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Expected %d, but observed %d instead (line %d)\n", a, b, line);
        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movl 0x5bcb(%rip), %esi      # 0xd834
incl %esi
movl %esi, 0x5bc3(%rip)      # 0xd834
cmpl %ebx, %edi
je 0x7ca4
movl %ecx, %r15d
leaq 0x1ff1(%rip), %rdi      # 0x9c70
xorl %eax, %eax
callq 0x20f0
leaq 0x1ff6(%rip), %rdi      # 0x9c83
movl %r14d, %esi
movl %ebx, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x20f0
incl 0x5b8e(%rip)            # 0xd830
jmp 0x7cb2
leaq 0x1fc9(%rip), %rdi      # 0x9c74
xorl %eax, %eax
callq 0x20f0
xorl %eax, %eax
cmpl %ebx, %r14d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_char_eq
int assert_char_eq(char a, char b, const char *testcase, int line)
{
    test_counter++;
    int err = a!=b;
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Expected %c, but observed %c instead (line %d)\n", a, b, line);
        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movl 0x5b56(%rip), %esi      # 0xd834
incl %esi
movl %esi, 0x5b4e(%rip)      # 0xd834
cmpb %bl, %r14b
je 0x7d23
movl %ecx, %r15d
movsbl %bl, %r12d
movsbl %r14b, %r13d
leaq 0x1f73(%rip), %rdi      # 0x9c70
xorl %eax, %eax
callq 0x20f0
leaq 0x1faa(%rip), %rdi      # 0x9cb5
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x20f0
incl 0x5b0f(%rip)            # 0xd830
jmp 0x7d31
leaq 0x1f4a(%rip), %rdi      # 0x9c74
xorl %eax, %eax
callq 0x20f0
xorl %eax, %eax
cmpb %bl, %r14b
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_true
int assert_true(int a, const char *testcase, int line)
{
    test_counter++;
    int err = !a;
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Failure on line %d\n", line);
        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rdx
movl %edi, %ebx
movl 0x5ad7(%rip), %esi      # 0xd834
incl %esi
movl %esi, 0x5acf(%rip)      # 0xd834
testl %edi, %edi
je 0x7d79
leaq 0x1f04(%rip), %rdi      # 0x9c74
xorl %eax, %eax
callq 0x20f0
jmp 0x7d9e
leaq 0x1ef0(%rip), %rdi      # 0x9c70
xorl %eax, %eax
callq 0x20f0
leaq 0x1f59(%rip), %rdi      # 0x9ce7
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
incl 0x5a92(%rip)            # 0xd830
xorl %eax, %eax
testl %ebx, %ebx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_str_eq
int assert_str_eq(const char *a, const char *b, const char *testcase, int line)
{
    test_counter++;
    int err = strcmp(a,b);
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Expected '%s', but observed '%s' instead (line %d)\n", a, b, line);
        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, -0x2c(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl 0x5a56(%rip), %r14d     # 0xd834
incl %r14d
movl %r14d, 0x5a4c(%rip)     # 0xd834
callq 0x21a0
movl %eax, %ebx
testl %eax, %eax
je 0x7e26
leaq 0x1e76(%rip), %rdi      # 0x9c70
movl %r14d, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x20f0
leaq 0x1eef(%rip), %rdi      # 0x9cfd
movq %r13, %rsi
movq %r12, %rdx
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
callq 0x20f0
incl 0x5a0c(%rip)            # 0xd830
jmp 0x7e3a
leaq 0x1e47(%rip), %rdi      # 0x9c74
movl %r14d, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x20f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_non_null
int assert_non_null(const void *v, const char *testcase, int line)
{
    test_counter++;
    int err = !v;
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Expected Non-NULL value, but observed NULL instead (line %d)\n", line);
        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rsi, %rdx
movq %rdi, %rbx
movl 0x59d3(%rip), %esi      # 0xd834
incl %esi
movl %esi, 0x59cb(%rip)      # 0xd834
testq %rdi, %rdi
je 0x7e7e
leaq 0x1dff(%rip), %rdi      # 0x9c74
xorl %eax, %eax
callq 0x20f0
jmp 0x7ea3
leaq 0x1deb(%rip), %rdi      # 0x9c70
xorl %eax, %eax
callq 0x20f0
leaq 0x1ea0(%rip), %rdi      # 0x9d33
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
incl 0x598d(%rip)            # 0xd830
xorl %eax, %eax
testq %rbx, %rbx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_f32_eq
int assert_f32_eq(float a, float b,const char *testcase, int line)
{
    test_counter++;
    int err = a!=b;
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Expected %f, but observed %f instead (line %d)\n", a, b, line);
        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %rdx
movl 0x5973(%rip), %esi      # 0xd834
incl %esi
movl %esi, 0x596b(%rip)      # 0xd834
movss %xmm1, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
ucomiss %xmm1, %xmm0
jne 0x7eda
jnp 0x7f10
leaq 0x1d8f(%rip), %rdi      # 0x9c70
xorl %eax, %eax
callq 0x20f0
xorps %xmm0, %xmm0
cvtss2sd -0xc(%rbp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd -0x10(%rbp), %xmm1
leaq 0x1e74(%rip), %rdi      # 0x9d73
movl %ebx, %esi
movb $0x2, %al
callq 0x20f0
incl 0x5922(%rip)            # 0xd830
jmp 0x7f1e
leaq 0x1d5d(%rip), %rdi      # 0x9c74
xorl %eax, %eax
callq 0x20f0
movss -0xc(%rbp), %xmm0
cmpneqss -0x10(%rbp), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/common.h
// Function: assert_hex_eq
int assert_hex_eq(const char *a, const char *b, size_t size_a, size_t size_b,
                  const char *testcase, int line)
{
    test_counter++;
    int err = (size_a != size_b) || memcmp(a, b, size_a);
    if(err) {
        printf("not ok %d - %s...\n", test_counter, testcase);
        printf("# Error on line %d\n", line);
        //printf("# Expected '%s', but observed '%s' instead (line %d)\n", a, b, line);

        //create difference mask
        const int longer  = size_a > size_b ? size_a : size_b;
        const int shorter = size_a < size_b ? size_a : size_b;
        char mask[longer];
        memset(mask, 0, longer);
        for(int i=0; i<shorter; ++i)
            if(a[i] != b[i])
                mask[i] = 1;

        printf("#\n");
        printf("# Expected:\n");
        hexdump(a, mask, size_a);
        printf("#\n");
        printf("# Observed:\n");
        hexdump(b, mask, size_b);

        global_err++;
    } else
        printf("ok %d - %s...\n", test_counter, testcase);
    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x38(%rbp)
movq %r8, %r13
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl 0x570a(%rip), %ebx      # 0xd834
incl %ebx
movl %ebx, 0x5702(%rip)      # 0xd834
movb $0x1, %al
movq %rcx, -0x40(%rbp)
cmpq %rcx, %rdx
jne 0x8150
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2220
testl %eax, %eax
setne %al
movb %al, -0x29(%rbp)
testb %al, %al
je 0x8231
leaq 0x1b0e(%rip), %rdi      # 0x9c70
movl %ebx, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x20f0
leaq 0x1c4a(%rip), %rdi      # 0x9dbf
movl -0x38(%rbp), %esi
xorl %eax, %eax
callq 0x20f0
movq -0x40(%rbp), %rbx
cmpq %rbx, %r15
movq %rbx, %rax
cmovaq %r15, %rax
cmovbq %r15, %rbx
movq %rsp, -0x38(%rbp)
movl %eax, %ecx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r13
subq %rcx, %r13
movq %r13, %rsp
movslq %eax, %rdx
movq %r13, %rdi
xorl %esi, %esi
callq 0x2140
testl %ebx, %ebx
jle 0x81d9
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %eax, %eax
movb (%r12,%rax), %cl
cmpb (%r14,%rax), %cl
je 0x81d1
movb $0x1, (%r13,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x81c1
leaq 0x1f06(%rip), %rbx      # 0xa0e6
movq %rbx, %rdi
callq 0x2080
leaq 0x1eeb(%rip), %rdi      # 0xa0da
callq 0x2080
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x7f37
movq %rbx, %rdi
callq 0x2080
leaq 0x1ed7(%rip), %rdi      # 0xa0e8
callq 0x2080
movq %r14, %rdi
movq %r13, %rsi
movq -0x40(%rbp), %rdx
callq 0x7f37
incl 0x5605(%rip)            # 0xd830
movq -0x38(%rbp), %rsp
jmp 0x8244
leaq 0x1a3c(%rip), %rdi      # 0x9c74
movl %ebx, %esi
movq %r13, %rdx
xorl %eax, %eax
callq 0x20f0
movzbl -0x29(%rbp), %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/basic-remote.c
// Function: print_response
void print_response(const char *osc, void *vv)
{
    char type = rtosc_type(osc, 0);
    //printf("[callback] got a message '%s':%c data=%p...\n", osc, type, v);

    rtosc_arg_t arg = rtosc_argument(osc, 0);

    if(!vv)
        return;
    void *v = *(void**)vv;


    if(type == 'i')
        *(int*)v = arg.i;
    else if(type == 'T')
        *(bool*)v = true;
    else if(type == 'F')
        *(bool*)v = false;
    else if(type == 'f')
        *(float*)v = arg.f;

    //if(type == 'i')
    //    printf("[callback] value = %d\n", arg.i);
    //else if(type == 'f')
    //    printf("[callback] value = %a\n", (double)arg.f);
    //else if(type == 'T')
    //    printf("[callback] value = true\n");
    //else if(type == 'F')
    //    printf("[callback] value = false\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0x67b9
movl %eax, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x725b
testq %rbx, %rbx
je 0x8340
movq (%rbx), %rcx
movzbl %r14b, %edx
cmpl $0x65, %edx
jg 0x832f
cmpl $0x46, %edx
je 0x833d
cmpl $0x54, %edx
jne 0x8340
movb $0x1, (%rcx)
jmp 0x8340
cmpl $0x66, %edx
je 0x8339
cmpl $0x69, %edx
jne 0x8340
movl %eax, (%rcx)
jmp 0x8340
movb $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mruby-zest[P]osc-bridge/test/basic-remote.c
// Function: test_lfo
void test_lfo(schema_t schema, bridge_t *bridge)
{
    for(unsigned i=0; i<sizeof(paths)/sizeof(paths[0]); ++i) {
        uri_t uri = paths[i];
        printf("#Testing address '%s'\n", uri);
        schema_handle_t handle = sm_get(schema, uri);

        assert_true(sm_valid(handle), "Verify Handle", __LINE__);

        //printf("(1#{%s} 2#{%s} 3#{%s} 4#{%s}\n",
        //sm_get_name(handle),    sm_get_short(handle),
        //sm_get_tooltip(handle), sm_get_units(handle));
        br_add_callback(bridge, uri, print_response, NULL);
        void **data = malloc(sizeof(void*));
        if(strstr(uri, "Pfreqrand")) {
            *data = &Pfreqrand;
            br_add_callback(bridge, uri, print_response, (void*)data);
        } else if(strstr(uri, "Pfreq")) {
            *data = &Pfreq;
            br_add_callback(bridge, uri, print_response, (void*)data);
        } else if(strstr(uri, "Pcontinous")) {
            *data = &Pcontinous;
            br_add_callback(bridge, uri, print_response, (void*)data);
        } else
            free(data);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq -0x7e(%rip), %r14       # 0x82eb
xorl %r13d, %r13d
leaq 0x4e3d(%rip), %rax      # 0xd1b0
movq (%r13,%rax), %r12
leaq 0x1c33(%rip), %rdi      # 0x9fb2
movq %r12, %rsi
xorl %eax, %eax
callq 0x20f0
leaq 0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x646c
movl $0xb, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x672d
movl %eax, %edi
leaq 0x1c01(%rip), %rsi      # 0x9fc9
movl $0x44, %edx
callq 0x7d48
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x34ee
movl $0x8, %edi
callq 0x2200
movq %rax, %r15
movq %r12, %rdi
leaq 0x1b25(%rip), %rsi      # 0x9f1e
callq 0x22d0
testq %rax, %rax
je 0x8418
leaq 0x4d9a(%rip), %rax      # 0xd1a4
movq %rax, (%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
jmp 0x8460
movq %r12, %rdi
leaq 0x1a11(%rip), %rsi      # 0x9e33
callq 0x22d0
testq %rax, %rax
je 0x8435
leaq 0x4d6d(%rip), %rax      # 0xd1a0
jmp 0x8450
movq %r12, %rdi
leaq 0x1b3a(%rip), %rsi      # 0x9f79
callq 0x22d0
testq %rax, %rax
je 0x847f
leaq 0x4d58(%rip), %rax      # 0xd1a8
movq %rax, (%r15)
movq %rbx, %rdi
movq %r12, %rsi
leaq -0x175(%rip), %rdx      # 0x82eb
movq %r15, %rcx
callq 0x34ee
addq $0x8, %r13
cmpq $0x48, %r13
leaq -0x18c(%rip), %r14      # 0x82eb
jne 0x836c
jmp 0x8489
movq %r15, %rdi
callq 0x2030
jmp 0x8468
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/error.c
// Function: print_diagnose
void print_diagnose(char *type, char *file, int line, char *format, va_list args) {
  fprintf(stderr, "[%s] %s:%d\n", type, file, line);
  vfprintf(stderr, format, args);
  fprintf(stderr, "\n");
  fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %rdx
movq 0x9ebd(%rip), %r15      # 0xaff8
movq (%r15), %rdi
leaq 0x5ebf(%rip), %rsi      # 0x7004
xorl %eax, %eax
callq 0x1090
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10f0
movq (%r15), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x1070
movq (%r15), %rsi
movl %ebx, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/error.c
// Function: print_error
void print_error(char *file, int line, char *format, ...) {
  va_list args;
  va_start(args, format);
  print_diagnose("error", file, line, format, args);
  va_end(args);
  exit(1);
}

// Assembly:
subq $0xd8, %rsp
movq %rdx, %r10
movl %esi, %edx
movq %rdi, %rsi
leaq 0x20(%rsp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1467
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 %rsp, %r8
movq %rdi, 0x10(%r8)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r8)
leaq 0x5b82(%rip), %rdi      # 0x7010
movq %r10, %rcx
callq 0x1120
movl $0x1, %edi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/utf8.c
// Function: check_sequence
int check_sequence(struct utf8c uc) {
  if(0x00 <= uc.sequence[0] && uc.sequence[0] <= 0x7F) { // 1-byte character
    if(uc.bytes != 1) return 0;
  } else if(0x80 <= uc.sequence[0] && uc.sequence[0] <= 0xC1) { // invalid sequence (not first byte)
    return 0;
  } else if(0xC2 <= uc.sequence[0] && uc.sequence[0] <= 0xDF) { // 2-bytes character
    if(uc.bytes != 2) return 0;
    if(!(0x80 <= uc.sequence[1] && uc.sequence[1] <= 0xC1)) return 0;
    if(uc.sequence[0] & 0x1E) return 0;
  } else if(0xE0 <= uc.sequence[0] && uc.sequence[0] <= 0xEF) { // 3-bytes character
    if(uc.bytes != 3) return 0;
    if(!(0x80 <= uc.sequence[1] && uc.sequence[1] <= 0xC1)) return 0;
    if(!(0x80 <= uc.sequence[2] && uc.sequence[2] <= 0xC1)) return 0;
    if((uc.sequence[0] & 0x0F) && (uc.sequence[1] & 0x20)) return 0;
  } else if(0xF0 <= uc.sequence[0] && uc.sequence[0] <= 0xF7) { // 4-bytes character
    if(uc.bytes != 4) return 0;
    if(!(0x80 <= uc.sequence[1] && uc.sequence[1] <= 0xC1)) return 0;
    if(!(0x80 <= uc.sequence[2] && uc.sequence[2] <= 0xC1)) return 0;
    if(!(0x80 <= uc.sequence[3] && uc.sequence[3] <= 0xC1)) return 0;
    if((uc.sequence[0] & 0x08) && (uc.sequence[1] & 0x30)) return 0;
  } else if(0xF8 <= uc.sequence[0] && uc.sequence[0] <= 0xFB) { // 5-bytes character
    return 0;
  } else if(0xFC <= uc.sequence[0] && uc.sequence[0] <= 0xFD) { // 6-bytes character
    return 0;
  } else if(uc.sequence[0] == 0xFE) { // invalid sequence
    return 0;
  } else if(uc.sequence[0] == 0xFF) { // EOF
    if(uc.bytes != 0) return 0;
    if(uc.sequence[0] != 0xFF) return 0;
  }
  return 1;
}

// Assembly:
movq %rdi, %rdx
shrq $0x20, %rdx
movzbl %dl, %r8d
xorl %eax, %eax
cmpl $0x7f, %r8d
ja 0x1501
cmpl $0x1, %edi
jne 0x150a
movl $0x1, %eax
retq
cmpl $0xc2, %r8d
jae 0x150b
retq
movq %rdi, %rcx
shrq $0x28, %rcx
cmpl $0xdf, %r8d
ja 0x1535
cmpl $0x2, %edi
jne 0x150a
testb $0x1e, %dl
jne 0x150a
andl $0xfe, %ecx
addl $-0x80, %ecx
cmpl $0x42, %ecx
jb 0x14fb
jmp 0x150a
movq %rdi, %rsi
shrq $0x30, %rsi
cmpl $0xef, %r8d
ja 0x157a
cmpl $0x3, %edi
jne 0x150a
movl %ecx, %edi
andl $0xfe, %edi
addl $-0x80, %edi
cmpl $0x41, %edi
ja 0x150a
andl $0xfe, %esi
addl $-0x80, %esi
cmpl $0x41, %esi
ja 0x150a
testb $0xf, %dl
sete %dl
testb $0x20, %cl
sete %cl
orb %dl, %cl
jne 0x14fb
jmp 0x150a
cmpl $0xf7, %r8d
ja 0x15c4
cmpl $0x4, %edi
jne 0x150a
andl $0xfe, %ecx
addl $-0x80, %ecx
cmpl $0x41, %ecx
ja 0x150a
movabsq $-0x3e00000000000001, %rcx # imm = 0xC1FFFFFFFFFFFFFF
cmpq %rcx, %rdi
jg 0x150a
andl $0xfe, %esi
addl $-0x80, %esi
cmpl $0x42, %esi
jb 0x14fb
jmp 0x150a
xorl $0xff, %r8d
orl %edi, %r8d
je 0x14fb
jmp 0x150a
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/utf8.c
// Function: code_point
struct utf8c code_point(int code) {
  int bit = 0;
  for(int i = code; i > 0; i /= 2) bit++;

  struct utf8c uc;
  if(0 <= bit && bit <= 7) {
    uc.bytes = 1;
    uc.sequence[0] = code;
  } else if(8 <= bit && bit <= 11) {
    uc.bytes = 2;
    uc.sequence[0] = ((code >> 6) & 0x1F) | 0xC0;
    uc.sequence[1] = (code & 0x3F) | 0x80;
  } else if(12 <= bit && bit <= 16) {
    uc.bytes = 3;
    uc.sequence[0] = ((code >> 12) & 0xF) | 0xE0;
    uc.sequence[1] = ((code >> 6) & 0x3F) | 0x80;
    uc.sequence[2] = (code & 0x3F) | 0x80;
  } else if(17 <= bit && bit <= 21) {
    uc.bytes = 4;
    uc.sequence[0] = ((code >> 18) & 0x7) | 0xF0;
    uc.sequence[1] = ((code >> 12) & 0x3F) | 0x80;
    uc.sequence[2] = ((code >> 6) & 0x3F) | 0x80;
    uc.sequence[3] = (code & 0x3F) | 0x80;
  } else {
    uc = ueof;
  }
  return uc;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
jle 0x15f7
movl %edi, %edx
movl %edi, %ecx
incl %eax
shrl %ecx
cmpl $0x2, %edx
movl %ecx, %edx
jae 0x15ec
cmpl $0x8, %eax
jae 0x1609
movl %edi, %eax
movl $0x1, %ecx
xorl %edi, %edi
xorl %esi, %esi
jmp 0x162b
cmpl $0xb, %eax
ja 0x1656
movl %edi, %eax
shrl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
andl $0x3f, %edi
orl $0x80, %edi
movl $0x2, %ecx
xorl %esi, %esi
xorl %r8d, %r8d
shlq $0x38, %r8
movzbl %sil, %esi
shlq $0x30, %rsi
orq %r8, %rsi
movzbl %dil, %edi
shlq $0x28, %rdi
orq %rsi, %rdi
movzbl %al, %eax
shlq $0x20, %rax
orq %rdi, %rax
orq %rcx, %rax
retq
cmpl $0x10, %eax
ja 0x168c
movl %edi, %eax
shrl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movl %edi, %r9d
shrl $0x6, %r9d
andl $0x3f, %r9d
movl $0x80, %ecx
orl %ecx, %r9d
andl $0x3f, %edi
movl %edi, %esi
orl %ecx, %esi
movl $0x3, %ecx
xorl %r8d, %r8d
jmp 0x16c9
cmpl $0x15, %eax
ja 0x16d1
movl %edi, %eax
shrl $0x12, %eax
andl $0x7, %eax
orl $0xf0, %eax
movl %edi, %r9d
shrl $0xc, %r9d
andl $0x3f, %r9d
movl $0x80, %ecx
orl %ecx, %r9d
movl %edi, %esi
shrl $0x6, %esi
andl $0x3f, %esi
orl %ecx, %esi
andl $0x3f, %edi
movl %edi, %r8d
orl %ecx, %r8d
movl $0x4, %ecx
movq %r9, %rdi
jmp 0x162e
movq 0x99c0(%rip), %rax      # 0xb098
movq %rax, %rdi
movq %rax, %rsi
movq %rax, %r8
movl %eax, %ecx
shrq $0x20, %rax
shrq $0x28, %rdi
shrq $0x30, %rsi
shrq $0x38, %r8
movb 0x99a7(%rip), %dl       # 0xb0a0
jmp 0x162e
nop
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/file.c
// Function: fget_utf8c
struct utf8c fget_utf8c(struct source *src) {
  struct utf8c uc;
  uc.sequence[0] = fgetc(src->fp);
  uc.bytes = count_bytes(uc.sequence[0]);

  if(uc.bytes == -1) {
    error("source file \"%s\" contains invalid sequence.\n", src->file);
  }

  if(uc.bytes == 0) {
    return ueof;
  }

  for(int i = 1; i < uc.bytes; i++) {
    uc.sequence[i] = fgetc(src->fp);
  }

  if(!check_sequence(uc)) {
    error("source file \"%s\" contains invalid sequence.\n", src->file);
  }

  uc.sequence[uc.bytes] = '\0';

  return uc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1060
movb %al, 0xc(%rsp)
movzbl %al, %edi
callq 0x14a0
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x17e2
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x1780
movq 0x8(%rbx), %rcx
leaq 0x58bd(%rip), %rdi      # 0x702a
leaq 0x58bd(%rip), %rdx      # 0x7031
movl $0x22, %esi
xorl %eax, %eax
callq 0x140c
cmpl $0x2, %ebp
jl 0x17a3
movl %ebp, %r14d
decq %r14
xorl %r15d, %r15d
movq (%rbx), %rdi
callq 0x1060
movb %al, 0xd(%rsp,%r15)
incq %r15
cmpq %r15, %r14
jne 0x178e
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x14e3
testl %eax, %eax
jne 0x17d3
movq 0x8(%rbx), %rcx
leaq 0x586a(%rip), %rdi      # 0x702a
leaq 0x586a(%rip), %rdx      # 0x7031
movl $0x2e, %esi
xorl %eax, %eax
callq 0x140c
leaq 0x8(%rsp), %rax
movslq (%rax), %rcx
movb $0x0, 0xc(%rsp,%rcx)
jmp 0x17e9
leaq 0x98af(%rip), %rax      # 0xb098
movb 0x8(%rax), %dl
movq (%rax), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/file.c
// Function: replace_trigraph
struct utf8c replace_trigraph(struct source *src) {
  unsigned char trigraph_symbol[9] = { '=', '(', '/', ')', '\'', '<', '!', '>', '-' };
  unsigned char trigraph_char[9] = { '#', '[', '\\', ']', '^', '{', '|', '}', '~' };

  for(; src->trigraph_queue_size < 3; src->trigraph_queue_size++) {
    src->trigraph_queue[src->trigraph_queue_size] = fget_utf8c(src);
    if(src->trigraph_queue[src->trigraph_queue_size].bytes == 0) {
      break;
    }
  }

  if(src->trigraph_queue_size == 0) {
    return ueof;
  }

  if(src->trigraph_queue_size == 3) {
    if(src->trigraph_queue[0].sequence[0] == '?') {
      if(src->trigraph_queue[1].sequence[0] == '?') {
        for(int i = 0; i < 9; i++) {
          if(src->trigraph_queue[2].sequence[0] == trigraph_symbol[i]) {
            struct utf8c uc = single_byte_char(trigraph_char[i]);
            src->trigraph_queue_size = 0;
            return uc;
          }
        }
      }
    }
  }

  struct utf8c uc = src->trigraph_queue[0];
  src->trigraph_queue_size--;
  for(int i = 0; i < src->trigraph_queue_size; i++) {
    src->trigraph_queue[i] = src->trigraph_queue[i + 1];
  }
  return uc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1c(%rdi), %r14
movl 0x18(%rdi), %eax
cmpl $0x2, %eax
jg 0x1842
cltq
leaq (%rax,%rax,2), %r15
movq %rbx, %rdi
callq 0x172e
movq %rax, (%r14,%r15,4)
movb %dl, 0x8(%r14,%r15,4)
movslq 0x18(%rbx), %rcx
leaq (%rcx,%rcx,2), %rax
cmpl $0x0, (%r14,%rax,4)
je 0x1842
leal 0x1(%rcx), %eax
movl %eax, 0x18(%rbx)
cmpl $0x2, %ecx
jl 0x1811
movl 0x18(%rbx), %eax
cmpl $0x3, %eax
je 0x1861
testl %eax, %eax
jne 0x18cb
leaq 0x9843(%rip), %rax      # 0xb098
movq (%rax), %r15
movb 0x8(%rax), %bpl
jmp 0x18fa
cmpb $0x3f, 0x20(%rbx)
jne 0x18cb
cmpb $0x3f, 0x2c(%rbx)
jne 0x18cb
movb 0x38(%rbx), %cl
cmpb $0x3d, %cl
jne 0x187c
xorl %eax, %eax
xorl %r12d, %r12d
jmp 0x18a4
xorl %edx, %edx
leaq 0x580e(%rip), %rsi      # 0x7093
cmpq $0x8, %rdx
je 0x18c2
leaq 0x1(%rdx), %rax
cmpb 0x1(%rdx,%rsi), %cl
movq %rax, %rdx
jne 0x1885
leaq -0x1(%rax), %rcx
cmpq $0x8, %rcx
setae %r12b
leaq 0x57f1(%rip), %rcx      # 0x709c
movzbl (%rax,%rcx), %edi
callq 0x15d9
movq %rax, %r15
movl %edx, %ebp
movl $0x0, 0x18(%rbx)
jmp 0x18c6
setae %r12b
testb %r12b, %r12b
je 0x18fa
movq 0x1c(%rbx), %r15
movb 0x24(%rbx), %bpl
movl 0x18(%rbx), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x18(%rbx)
cmpl $0x2, %ecx
jl 0x18fa
addq $0x28, %rbx
movl %eax, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10c0
movq %r15, %rax
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/file.c
// Function: splice_line
struct utf8c splice_line(struct source *src) {
  for(; src->splice_queue_size < 3; src->splice_queue_size++) {
    src->splice_queue[src->splice_queue_size] = replace_trigraph(src);
    if(src->splice_queue[src->splice_queue_size].bytes == 0) {
      break;
    }
  }

  if(src->splice_queue_size == 0) {
    return ueof;
  }

  if(src->splice_queue_size >= 2) {
    if(src->splice_queue[0].sequence[0] == '\\') {
      if(src->splice_queue[1].sequence[0] == '\n') {
        if(src->splice_queue_size == 2) {
          error("end of the source file requires new line indicator.\n");
        }
        src->splice_queue_size = 0;
        return src->splice_queue[2];
      }
    }
  }

  struct utf8c uc = src->splice_queue[0];
  src->splice_queue_size--;
  for(int i = 0; i < src->splice_queue_size; i++) {
    src->splice_queue[i] = src->splice_queue[i + 1];
  }
  return uc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x44(%rdi), %r14
movl 0x40(%rdi), %eax
cmpl $0x2, %eax
jg 0x194f
cltq
leaq (%rax,%rax,2), %r15
movq %rbx, %rdi
callq 0x17fa
movq %rax, (%r14,%r15,4)
movb %dl, 0x8(%r14,%r15,4)
movslq 0x40(%rbx), %rcx
leaq (%rcx,%rcx,2), %rax
cmpl $0x0, (%r14,%rax,4)
je 0x194f
leal 0x1(%rcx), %eax
movl %eax, 0x40(%rbx)
cmpl $0x2, %ecx
jl 0x191e
movl 0x40(%rbx), %eax
testl %eax, %eax
je 0x19c5
cmpl $0x2, %eax
jl 0x1997
cmpb $0x5c, 0x48(%rbx)
jne 0x1997
cmpb $0xa, 0x54(%rbx)
jne 0x1997
cmpl $0x2, %eax
jne 0x1986
leaq 0x56b7(%rip), %rdi      # 0x702a
leaq 0x56e4(%rip), %rdx      # 0x705e
movl $0x6b, %esi
xorl %eax, %eax
callq 0x140c
movl $0x0, 0x40(%rbx)
movq 0x5c(%rbx), %r15
movb 0x64(%rbx), %bpl
jmp 0x19d3
movq 0x44(%rbx), %r15
movb 0x4c(%rbx), %bpl
leal -0x1(%rax), %ecx
movl %ecx, 0x40(%rbx)
cmpl $0x2, %eax
jl 0x19d3
addq $0x50, %rbx
movl %ecx, %eax
shlq $0x2, %rax
leaq (%rax,%rax,2), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10c0
jmp 0x19d3
leaq 0x96cc(%rip), %rax      # 0xb098
movq (%rax), %r15
movb 0x8(%rax), %bpl
movq %r15, %rax
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/string.c
// Function: allocate_string
struct string *allocate_string() {
  const int INIT_SIZE = 4;

  struct string *str = (struct string *) malloc(sizeof(struct string));
  str->head = (unsigned char *) malloc(sizeof(unsigned char) * (INIT_SIZE + 1));
  str->size = 0;
  str->alloc_size = INIT_SIZE;
  str->head[0] = '\0';

  return str;
}

// Assembly:
pushq %rbx
movl $0x10, %edi
callq 0x10b0
movq %rax, %rbx
movl $0x5, %edi
callq 0x10b0
movq %rax, (%rbx)
movabsq $0x400000000, %rcx      # imm = 0x400000000
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/string.c
// Function: append_string
void append_string(struct string *str, unsigned char c) {
  if(str->size >= str->alloc_size) {
    int new_size = str->alloc_size * 2;
    unsigned char *t = (unsigned char *) malloc(sizeof(unsigned char) * (new_size + 1));
    for(int i = 0; i < str->size; i++) t[i] = str->head[i];

    free(str->head);

    str->head = t;
    str->alloc_size = new_size;
  }

  str->head[str->size++] = c;
  str->head[str->size] = '\0';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %r12d
movslq 0xc(%rdi), %r15
cmpl %r15d, %r12d
jl 0x1a6e
leaq 0x1(,%r15,2), %rdi
addq %r15, %r15
callq 0x10b0
movq %rax, %r14
testl %r12d, %r12d
jle 0x1a5f
movq (%rbx), %rax
xorl %ecx, %ecx
movb (%rax,%rcx), %dl
movb %dl, (%r14,%rcx)
incq %rcx
cmpq %rcx, %r12
jne 0x1a50
movq (%rbx), %rdi
callq 0x1030
movq %r14, (%rbx)
movl %r15d, 0xc(%rbx)
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rbx)
movb %bpl, (%rax,%rcx)
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/lex.c
// Function: allocate_pp_token_lexer
struct pp_token_lexer *allocate_pp_token_lexer(const unsigned char *file) {
  const int INIT_SIZE = 64;

  struct pp_token_lexer *lexer = (struct pp_token_lexer *) malloc(sizeof(struct pp_token_lexer));
  if(lexer == NULL) {
    perror("malloc");
    exit(1);
  }

  lexer->src = allocate_source(file);
  lexer->comment_queue_size = 0;
  lexer->queue = (struct utf8c *) malloc(sizeof(struct utf8c) * INIT_SIZE);
  lexer->queue_head = 0;
  lexer->queue_size = 0;
  lexer->queue_allocate_size = INIT_SIZE;
  lexer->context = CTX_NL;

  while(1) {
    struct utf8c uc = remove_comment(lexer);
    unsigned char c = uc.sequence[0];
    if(!(c == ' ' || c == '\t' || c == '\v' || c == '\f' || c == '\n')) {
      push_char_queue(lexer, uc);
      break;
    }
  }

  return lexer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x40, %edi
callq 0x10b0
testq %rax, %rax
je 0x1bbf
movq %rax, %rbx
movq %r14, %rdi
callq 0x1700
movq %rax, (%rbx)
movl $0x0, 0x8(%rbx)
movl $0x300, %edi            # imm = 0x300
callq 0x10b0
movq %rax, 0x28(%rbx)
movaps 0x5558(%rip), %xmm0     # 0x70b0
movups %xmm0, 0x30(%rbx)
movabsq $0xfd00000000, %r14     # imm = 0xFD00000000
movabsq $0x900000000, %r15      # imm = 0x900000000
movabsq $0x100001400, %r12      # imm = 0x100001400
movq %rbx, %rdi
callq 0x1bc4
movq %rax, %rcx
andq %r14, %rcx
cmpq %r15, %rcx
je 0x1b7a
movq %rax, %rcx
shrq $0x20, %rcx
cmpb $0x20, %cl
ja 0x1ba2
movzbl %cl, %ecx
btq %rcx, %r12
jb 0x1b7a
movzbl %dl, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1d6d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x12af
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/lex.c
// Function: push_char_queue
void push_char_queue(struct pp_token_lexer *lexer, struct utf8c uc) {
  if(lexer->queue_size >= lexer->queue_allocate_size) {
    struct utf8c *t = (struct utf8c *) malloc(sizeof(struct utf8c) * lexer->queue_allocate_size * 2);
    if(t == NULL) {
      perror("malloc");
      exit(1);
    }
    for(int i = 0; i < lexer->queue_size; i++) {
      t[i] = lexer->queue[(lexer->queue_head + i) % lexer->queue_allocate_size];
    }
    lexer->queue = t;
    lexer->queue_head = 0;
    lexer->queue_allocate_size *= 2;
  }
  lexer->queue[(lexer->queue_head + lexer->queue_size) % lexer->queue_allocate_size] = uc;
  lexer->queue_size++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x34(%rdi), %r12d
movslq 0x38(%rdi), %r13
cmpl %r13d, %r12d
jl 0x1e00
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x10b0
testq %rax, %rax
je 0x1e2d
movq %rax, %rcx
testl %r12d, %r12d
jle 0x1ded
movq 0x28(%r14), %rdi
movl 0x30(%r14), %esi
leaq (,%r12,4), %rax
leaq (%rax,%rax,2), %r8
xorl %r9d, %r9d
movl %esi, %eax
cltd
idivl %r13d
movslq %edx, %rax
leaq (%rax,%rax,2), %rax
movl 0x8(%rdi,%rax,4), %edx
movl %edx, 0x8(%rcx,%r9)
movq (%rdi,%rax,4), %rax
movq %rax, (%rcx,%r9)
incl %esi
addq $0xc, %r9
cmpq %r9, %r8
jne 0x1dc4
movq %rcx, 0x28(%r14)
movl $0x0, 0x30(%r14)
addl %r13d, %r13d
movl %r13d, 0x38(%r14)
movq 0x28(%r14), %rcx
addl 0x30(%r14), %r12d
movl %r12d, %eax
cltd
idivl 0x38(%r14)
movslq %edx, %rax
leaq (%rax,%rax,2), %rax
movq %r15, (%rcx,%rax,4)
movb %bl, 0x8(%rcx,%rax,4)
incl 0x34(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x12c4
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/lex.c
// Function: allocate_pp_token
struct pp_token *allocate_pp_token() {
  struct pp_token *token = (struct pp_token *) malloc(sizeof(struct pp_token));
  if(token == NULL) {
    perror("malloc");
    exit(1);
  }
  token->text = allocate_string();
  return token;
}

// Assembly:
pushq %rbx
movl $0x20, %edi
callq 0x10b0
testq %rax, %rax
je 0x1e55
movq %rax, %rbx
xorl %eax, %eax
callq 0x19e8
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x12d9
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/lex.c
// Function: pop_char_queue
struct utf8c pop_char_queue(struct pp_token_lexer *lexer) {
  if(lexer->queue_size == 0) {
    error("internal: lexer character queue is empty\n");
  }

  struct utf8c uc = lexer->queue[lexer->queue_head];
  lexer->queue_head++;
  lexer->queue_head %= lexer->queue_allocate_size;
  lexer->queue_size--;
  return uc;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x34(%rdi)
jne 0x1eb2
leaq 0x5d48(%rip), %rdi      # 0x7be7
leaq 0x5db5(%rip), %rdx      # 0x7c5b
movl $0x9f, %esi
xorl %eax, %eax
callq 0x140c
movq 0x28(%rbx), %rax
movslq 0x30(%rbx), %rdx
leaq (%rdx,%rdx,2), %rsi
movq (%rax,%rsi,4), %rcx
movb 0x8(%rax,%rsi,4), %sil
leal 0x1(%rdx), %eax
cltd
idivl 0x38(%rbx)
movl %edx, 0x30(%rbx)
decl 0x34(%rbx)
movq %rcx, %rax
movl %esi, %edx
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/preprocess.c
// Function: allocate_pp_list
struct pp_list *allocate_pp_list() {
  struct pp_list *list = (struct pp_list *) malloc(sizeof(struct pp_list));
  if(list == NULL) {
    perror("malloc");
    exit(1);
  }
  list->head = NULL;
  list->tail = &(list->head);
  return list;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x10b0
testq %rax, %rax
je 0x3aed
movq $0x0, (%rax)
movq %rax, 0x8(%rax)
popq %rcx
retq
callq 0x12ee
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/preprocess.c
// Function: free_pp_list
void free_pp_list(struct pp_list *list) {
  struct pp_node *node = list->head;
  while(node != NULL) {
    struct pp_node *next = node->next;
    free(node);
    node = next;
  }
  free(list);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x3b12
movq 0x8(%rdi), %r14
callq 0x1030
movq %r14, %rdi
testq %r14, %r14
jne 0x3b01
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/preprocess.c
// Function: append_pp_list
void append_pp_list(struct pp_list *list, struct pp_token *token) {
  struct pp_node *node = (struct pp_node *) malloc(sizeof(struct pp_node));
  node->token = token;
  node->next = NULL;
  node->skip = 0;
  *(list->tail) = node;
  list->tail = &(node->next);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x10b0
movq %rbx, (%rax)
leaq 0x8(%rax), %rcx
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movq 0x8(%r14), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/preprocess.c
// Function: allocate_macro_entry
struct macro_entry *allocate_macro_entry() {
  struct macro_entry *macro = (struct macro_entry *) malloc(sizeof(struct macro_entry));
  if(macro == NULL) {
    perror("malloc");
    exit(1);
  }
  macro->replacement_list = allocate_pp_list();
  macro->expanded = 0;
  return macro;
}

// Assembly:
pushq %rbx
movl $0x428, %edi            # imm = 0x428
callq 0x10b0
testq %rax, %rax
je 0x3ba4
movq %rax, %rbx
callq 0x3ad0
movq %rax, 0x418(%rbx)
movl $0x0, 0x420(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x1303
// File: /workspace/github_c_makefile_star2_O1/ShinyaKato[P]skcc/preprocess.c
// Function: ident_hash
int ident_hash(const unsigned char *ident) {
  const int BASE = 257;
  int h = 0;
  for(int i = 0; ident[i] != '\0'; i++) {
    h = (h * BASE + ident[i]) % MACRO_TABLE_SIZE;
  }
  return h;
}

// Assembly:
movb (%rdi), %dl
testb %dl, %dl
je 0x3bfd
incq %rdi
xorl %esi, %esi
movl $0xcccb8521, %ecx       # imm = 0xCCCB8521
movzbl %dl, %edx
movl %esi, %eax
shll $0x8, %eax
addl %esi, %eax
addl %edx, %eax
movq %rax, %rdx
imulq %rcx, %rdx
shrq $0x2f, %rdx
imull $0xa001, %edx, %edx     # imm = 0xA001
subl %edx, %eax
movb (%rdi), %dl
incq %rdi
movl %eax, %esi
testb %dl, %dl
jne 0x3bd2
retq
xorl %eax, %eax
retq