LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_query_string_del
MM_JSON_API mm_json_int
mm_json_query_string_del(mm_json_char *buffer, mm_json_size max, mm_json_size *size,
    struct mm_json_token *toks, mm_json_size count, const mm_json_char *path, mm_json_char del)
{
    struct mm_json_token *tok;
    MM_JSON_ASSERT(toks);
    MM_JSON_ASSERT(count);
    MM_JSON_ASSERT(buffer);
    MM_JSON_ASSERT(size);
    MM_JSON_ASSERT(path);
    if (!toks || !count || !buffer || !size || !path)
        return MM_JSON_NONE;

    tok = mm_json_query_del(toks, count, path, del);
    if (!tok) return MM_JSON_NONE;
    if (tok->type != MM_JSON_STRING)
        return tok->type;
    *size = mm_json_cpy(buffer, max, tok);
    return tok->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %r9, %r9
je 0x5249
movq %rdx, %r14
testq %rdx, %rdx
je 0x5249
movq %rdi, %r12
testq %rdi, %rdi
je 0x5249
testq %rcx, %rcx
je 0x5249
testq %r8, %r8
je 0x5249
movq %rsi, %r15
movsbl 0x10(%rbp), %eax
movq %rcx, %rdi
movq %r8, %rsi
movq %r9, %rdx
movl %eax, %ecx
callq 0x4cfe
testq %rax, %rax
je 0x5249
movq %rax, %r13
movl 0x20(%rax), %ebx
cmpl $0x4, %ebx
jne 0x5249
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x458f
movq %rax, (%r14)
movl 0x20(%r13), %ebx
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_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_query_type_del
MM_JSON_API mm_json_int
mm_json_query_type_del(struct mm_json_token *toks, mm_json_size count, const mm_json_char *path,
    mm_json_char del)
{
    struct mm_json_token *tok;
    MM_JSON_ASSERT(toks);
    MM_JSON_ASSERT(count);
    MM_JSON_ASSERT(path);
    if (!toks || !count || !path)
        return MM_JSON_NONE;

    tok = mm_json_query_del(toks, count, path, del);
    if (!tok) return MM_JSON_NONE;
    return tok->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
testq %rdx, %rdx
sete %al
xorl %ebx, %ebx
orb %r8b, %al
jne 0x52a7
movsbl %cl, %ecx
callq 0x4cfe
testq %rax, %rax
je 0x52a7
movl 0x20(%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/parse-schema.c
// Function: strndup_custom
static char *strndup_custom(const char *data, int len)
{
    char *dest = calloc(len+1,1);
    for(int i=0; i<len; ++i)
        dest[i] = data[i];
    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
movslq %eax, %rdi
pushq $0x1
popq %rsi
callq 0x2180
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x558c
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x557b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/parse-schema.c
// Function: parse_range
void parse_range(schema_handle_t *handle, const char *str, int len)
{
    struct mm_json_iter array = mm_json_begin(str, len);
    struct mm_json_token tok;
    array = mm_json_read(&tok, &array);
    if(!array.src) {
        fprintf(stdout, "[WARNING] Unexpected range termination in parse_range()\n");
        return;
    }

    if(tok.type == MM_JSON_NUMBER)
        handle->value_min = atof(tok.str);
    else
        fprintf(stdout, "[WARNING] Unexpected Range Type %d For Min\n", tok.type);

    array = mm_json_read(&tok, &array);
    if(!array.src) {
        fprintf(stdout, "[WARNING] Unexpected range termination in parse_range() P2\n");
        return;
    }

    if(tok.type == MM_JSON_NUMBER)
        handle->value_max = atof(tok.str);
    else
        fprintf(stdout, "[WARNING] Unexpected Range Type %d For Max\n", tok.type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %r12
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %r15
movaps %xmm0, (%r15)
callq 0x40cc
movq %r14, 0x10(%r15)
movq %r12, 0x18(%r15)
leaq -0x90(%rbp), %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x465c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%r15)
movaps %xmm0, (%r15)
cmpq $0x0, 0x10(%r15)
je 0x560c
movl -0x28(%rbp), %edx
cmpl $0x3, %edx
jne 0x5621
movq -0x48(%rbp), %rdi
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4c(%rbx)
jmp 0x5639
movq 0x69c5(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x301f(%rip), %rdi      # 0x863c
pushq $0x38
jmp 0x5690
movq 0x69b0(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x3043(%rip), %rsi      # 0x8675
xorl %eax, %eax
callq 0x21b0
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x465c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%r15)
movaps %xmm0, (%r15)
cmpq $0x0, 0x10(%r15)
je 0x567d
movl -0x28(%rbp), %edx
cmpl $0x3, %edx
jne 0x569b
movq -0x48(%rbp), %rdi
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x50(%rbx)
jmp 0x56b3
movq 0x6954(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x3013(%rip), %rdi      # 0x86a1
pushq $0x3b
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
jmp 0x56b3
movq 0x6936(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x3031(%rip), %rsi      # 0x86dd
xorl %eax, %eax
callq 0x21b0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_strchr
static const mm_json_char*
mm_json_strchr(const mm_json_char *str, mm_json_char c, mm_json_int len)
{
    mm_json_int neg = (len < 0) ? 1: 0;
    mm_json_int dec = neg ? 0 : 1;
    len = neg ? 0 : len;
    if (!str) return NULL;
    while (*str && len >= 0) {
        if (*str == c)
            return str;
        len -= dec;
        str++;
    }
    if (neg) return str;
    return NULL;
}

// Assembly:
xorl %ecx, %ecx
testq %rdi, %rdi
je 0x5d48
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %edx, %edi
notl %edi
sarl $0x1f, %edi
testl %edx, %edx
cmovnsl %edx, %ecx
movb (%rax), %r8b
testb %r8b, %r8b
je 0x5d4b
testl %ecx, %ecx
js 0x5d4b
cmpb %sil, %r8b
je 0x5d53
addl %edi, %ecx
incq %rax
jmp 0x5d30
xorl %eax, %eax
retq
xorl %ecx, %ecx
testl %edx, %edx
cmovnsq %rcx, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/schema.c
// Function: br_destroy_schema
void br_destroy_schema(schema_t sch)
{
    free(sch.json);
    for(int i=0; i<sch.elements; ++i) {
        if(sch.handles[i].opts) {
            free(sch.handles[i].opts->ids);
            for(size_t j=0; j<sch.handles[i].opts->num_opts; ++j)
                free((void*)sch.handles[i].opts->labels[j]);
            free(sch.handles[i].opts->labels);
        }
        free((void*)sch.handles[i].documentation);
        free((void*)sch.handles[i].name);
        free((void*)sch.handles[i].short_name);
        free((void*)sch.handles[i].pattern);
        free((void*)sch.handles[i].default_);
        free(sch.handles[i].opts);
    }
    free(sch.handles);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rbp), %rdi
callq 0x2030
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rbx
xorl %r15d, %r15d
testl %eax, %eax
cmovlel %r15d, %eax
movq %rax, -0x30(%rbp)
cmpq -0x30(%rbp), %r15
je 0x5e13
imulq $0x58, %r15, %r13
leaq (%rbx,%r13), %r12
addq $0x8, %r12
movq (%r12), %rax
testq %rax, %rax
je 0x5dd0
movq (%rax), %rdi
callq 0x2030
xorl %r14d, %r14d
movq (%r12), %rax
movl 0x10(%rax), %ecx
movq 0x8(%rax), %rdi
cmpq %rcx, %r14
jae 0x5dcb
movq (%rdi,%r14,8), %rdi
callq 0x2030
incq %r14
jmp 0x5dad
callq 0x2030
movq 0x30(%rbx,%r13), %rdi
callq 0x2030
movq 0x18(%rbx,%r13), %rdi
callq 0x2030
movq 0x20(%rbx,%r13), %rdi
callq 0x2030
movq 0x10(%rbx,%r13), %rdi
callq 0x2030
movq 0x40(%rbx,%r13), %rdi
callq 0x2030
movq (%r12), %rdi
callq 0x2030
incq %r15
jmp 0x5d83
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_argument_string
const char *rtosc_argument_string(const char *msg)
{
    assert(msg && *msg);
    while(*++msg); //skip pattern
    while(!*++msg);//skip null
    return msg+1;  //skip comma
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x60f4
cmpb $0x0, (%rdi)
je 0x60f4
incq %rdi
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x60dd
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
je 0x60e6
movq %rdi, %rax
popq %rbp
retq
leaq 0x2985(%rip), %rdi      # 0x8a80
leaq 0x298a(%rip), %rsi      # 0x8a8c
leaq 0x2991(%rip), %rcx      # 0x8a9a
pushq $0xd
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_narguments
unsigned rtosc_narguments(const char *msg)
{
    const char *args = rtosc_argument_string(msg);
    int nargs = 0;
    while(*args++)
        nargs += (*args == ']' || *args == '[') ? 0 : 1;
    return nargs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x60cc
movb (%rax), %dl
incq %rax
xorl %ecx, %ecx
testb %dl, %dl
je 0x613a
movb (%rax), %dl
leal -0x5b(%rdx), %esi
andb $-0x3, %sil
cmpb $0x1, %sil
sbbl $-0x1, %ecx
incq %rax
jmp 0x6121
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_type
char rtosc_type(const char *msg, unsigned nargument)
{
    assert(nargument < rtosc_narguments(msg));
    const char *arg = rtosc_argument_string(msg);
    while(1) {
        if(*arg == '[' || *arg == ']')
            ++arg;
        else if(!nargument || !*arg)
            return *arg;
        else
            ++arg, --nargument;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x6111
cmpl %ebx, %eax
jbe 0x617e
movq %r14, %rdi
callq 0x60cc
movzbl (%rax), %ecx
cmpl $0x5b, %ecx
je 0x6172
cmpl $0x5d, %ecx
je 0x6172
testl %ebx, %ebx
je 0x6177
testb %cl, %cl
je 0x6177
decl %ebx
incq %rax
jmp 0x615b
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2945(%rip), %rdi      # 0x8aca
leaq 0x2900(%rip), %rsi      # 0x8a8c
leaq 0x2959(%rip), %rcx      # 0x8aec
pushq $0x45
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: nreserved
static unsigned nreserved(const char *args)
{
    unsigned res = 0;
    for(;*args;++args)
        res += has_reserved(*args);

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl $0x1, %ecx
movabsq $0x708d70002000, %rdx   # imm = 0x708D70002000
movl $0xa04109, %esi         # imm = 0xA04109
movzbl (%rdi), %r8d
leal -0x46(%r8), %r9d
cmpl $0x2e, %r9d
ja 0x64ca
btq %r9, %rdx
movl %ecx, %r10d
jb 0x64c2
btq %r9, %rsi
jae 0x64ca
xorl %r10d, %r10d
addl %r10d, %eax
incq %rdi
jmp 0x64a2
testl %r8d, %r8d
jne 0x64bf
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_itr_begin
rtosc_arg_itr_t rtosc_itr_begin(const char *msg)
{
    rtosc_arg_itr_t itr;
    itr.type_pos  = advance_past_dummy_args(rtosc_argument_string(msg));
    itr.value_pos = (uint8_t*)(msg+arg_start(msg));

    return itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x60cc
movq %rax, %rdi
callq 0x68f8
movq %rax, %r14
movq %rbx, %rdi
callq 0x60cc
movq %rax, %rsi
subq %rbx, %rsi
addq $0x4, %rsi
pushq $0x1
popq %rcx
incq %rsi
cmpb $0x0, (%rax,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x68d0
pushq $0x4
popq %rdi
movq %rcx, %rax
cqto
idivq %rdi
subl %edx, %esi
addq %rsi, %rbx
movq %r14, %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: rtosc_itr_next
rtosc_arg_val_t rtosc_itr_next(rtosc_arg_itr_t *itr)
{
    //current position provides the value
    rtosc_arg_val_t result = {0,{0}};
    result.type = *itr->type_pos;
    if(result.type)
        result.val = extract_arg(itr->value_pos, result.type);

    //advance
    itr->type_pos = advance_past_dummy_args(itr->type_pos+1);
    char type = result.type;
    int size  = arg_size(itr->value_pos, type);
    itr->value_pos += size;


    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r12
movb (%r12), %al
movb %al, (%rdi)
movsbl %al, %r15d
testb %al, %al
je 0x6954
movq 0x8(%rbx), %rdi
movl %r15d, %esi
callq 0x6986
movq %rax, 0x8(%r14)
movq %rdx, 0x10(%r14)
incq %r12
movq %r12, %rdi
callq 0x68f8
movq %rax, (%rbx)
movq 0x8(%rbx), %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x6aa1
cltq
addq %r12, %rax
movq %rax, 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %ecx, %ecx
leal -0x53(%rsi), %eax
cmpl $0x21, %eax
ja 0x6b50
movabsq $0x3846b8001, %rdx      # imm = 0x3846B8001
btq %rax, %rdx
jae 0x6b50
movsbl %sil, %ecx
leal -0x62(%rcx), %eax
cmpl $0x12, %eax
ja 0x6af1
leaq 0x1f0e(%rip), %rcx      # 0x89e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, %ecx
jmp 0x6b50
movl $0x8, %ecx
jmp 0x6b50
cmpl $0x53, %ecx
jne 0x6b19
xorl %ecx, %ecx
cmpb $0x0, 0x1(%rdi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x6af8
movabsq $0x4, %rsi
movq %rcx, %rax
cqto
idivq %rsi
subl %edx, %ecx
jmp 0x6b4d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x6b50
movzbl (%rdi), %eax
shll $0x18, %eax
movzbl 0x1(%rdi), %ecx
shll $0x10, %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
shll $0x8, %eax
orl %ecx, %eax
movzbl 0x3(%rdi), %edx
orl %edx, %eax
andl $0x3, %edx
movl %eax, %ecx
subl %edx, %ecx
addl $0x4, %ecx
testl %edx, %edx
cmovel %eax, %ecx
addl $0x4, %ecx
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7034
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movl %r15d, %eax
cmpq %rbx, %rax
jae 0x7037
movsbq (%r14,%r15), %r12
testq %r12, %r12
je 0x7037
callq 0x22f0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r12,2)
je 0x7081
incq %r15
jmp 0x700d
xorl %eax, %eax
retq
cmpq %r15, %rbx
movq %r15, %rax
cmovaq %rbx, %rax
movq %r15, %rcx
cmpq %rcx, %rax
je 0x7058
cmpb $0x2c, (%r14,%rcx)
je 0x7055
incq %rcx
jmp 0x7044
movq %rcx, %rax
movq %rax, %rcx
subq %r15, %rcx
cmpq $0x5, %rcx
setae %cl
testb $0x3, %al
setne %al
orb %cl, %al
jne 0x7081
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6fcc
cmpq %rbx, %rax
sete %al
jmp 0x7083
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0xd8, %rsp
movl %ecx, %r15d
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
leaq -0x100(%rbp), %r12
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x70f0
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x2140
movabsq $0x656c646e756223, %rax # imm = 0x656C646E756223
movq %rax, (%rbx)
movq %r14, %rcx
movq %r14, %rax
shrq $0x38, %rax
movb %al, 0x8(%rbx)
movq %r14, %rax
shrq $0x30, %rax
movb %al, 0x9(%rbx)
movq %r14, %rax
shrq $0x28, %rax
movb %al, 0xa(%rbx)
movq %r14, %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), %r14
movq %r12, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, -0x40(%rbp)
testl %r15d, %r15d
cmovgl %r15d, %r13d
pushq $-0x1
popq %r15
subl $0x1, %r13d
jb 0x71cd
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0x7193
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0x719f
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6fcc
movq %rax, %r12
bswapl %eax
movl %eax, (%r14)
leaq 0x4(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x21e0
addq %r12, %r14
addq $0x4, %r14
jmp 0x7175
subq -0x48(%rbp), %r14
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %r12
xorl %r15d, %r15d
movq %r12, %rax
subq %r14, %rax
cmpq %rbx, %rax
jae 0x722f
movq %r12, %rdi
callq 0x723b
testl %eax, %eax
je 0x722f
andl $-0x4, %eax
addq %rax, %r12
addq $0x4, %r12
movq %r12, %rax
subq %r14, %rax
cmpq %rbx, %rax
ja 0x722f
incq %r15
jmp 0x71fe
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rbx
movl %esi, %r14d
movq %r14, %r15
subq $0x1, %r15
jb 0x727d
movq %rbx, %rdi
callq 0x723b
testl %eax, %eax
je 0x727d
andl $-0x4, %eax
addq %rax, %rbx
addq $0x4, %rbx
movq %r15, %r14
jmp 0x725c
addq $0x4, %rbx
xorl %eax, %eax
testq %r14, %r14
cmoveq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x10, %rbx
movl %esi, %r15d
xorl %r14d, %r14d
subq $0x1, %r15
jb 0x72cd
movq %rbx, %rdi
callq 0x723b
testl %eax, %eax
je 0x72cd
movl %eax, %r14d
andl $-0x4, %eax
addq %rax, %rbx
addq $0x4, %rbx
jmp 0x72ac
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x551b(%rip), %esi      # 0xc834
incl %esi
movl %esi, 0x5513(%rip)      # 0xc834
cmpl %ebx, %edi
je 0x7354
movl %ecx, %r15d
leaq 0x18fd(%rip), %rdi      # 0x8c2c
xorl %eax, %eax
callq 0x20f0
leaq 0x1902(%rip), %rdi      # 0x8c3f
movl %r14d, %esi
movl %ebx, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x20f0
incl 0x54de(%rip)            # 0xc830
jmp 0x7362
leaq 0x18d5(%rip), %rdi      # 0x8c30
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_O2/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 0x54a6(%rip), %esi      # 0xc834
incl %esi
movl %esi, 0x549e(%rip)      # 0xc834
cmpb %bl, %r14b
je 0x73d3
movl %ecx, %r15d
movsbl %bl, %r12d
movsbl %r14b, %r13d
leaq 0x187f(%rip), %rdi      # 0x8c2c
xorl %eax, %eax
callq 0x20f0
leaq 0x18b6(%rip), %rdi      # 0x8c71
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x20f0
incl 0x545f(%rip)            # 0xc830
jmp 0x73e1
leaq 0x1856(%rip), %rdi      # 0x8c30
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_O2/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 0x5427(%rip), %esi      # 0xc834
incl %esi
movl %esi, 0x541f(%rip)      # 0xc834
testl %edi, %edi
je 0x7429
leaq 0x1810(%rip), %rdi      # 0x8c30
xorl %eax, %eax
callq 0x20f0
jmp 0x744e
leaq 0x17fc(%rip), %rdi      # 0x8c2c
xorl %eax, %eax
callq 0x20f0
leaq 0x1865(%rip), %rdi      # 0x8ca3
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
incl 0x53e2(%rip)            # 0xc830
xorl %eax, %eax
testl %ebx, %ebx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x53a6(%rip), %r14d     # 0xc834
incl %r14d
movl %r14d, 0x539c(%rip)     # 0xc834
callq 0x21a0
movl %eax, %ebx
testl %eax, %eax
je 0x74d6
leaq 0x1782(%rip), %rdi      # 0x8c2c
movl %r14d, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x20f0
leaq 0x17fb(%rip), %rdi      # 0x8cb9
movq %r13, %rsi
movq %r12, %rdx
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
callq 0x20f0
incl 0x535c(%rip)            # 0xc830
jmp 0x74ea
leaq 0x1753(%rip), %rdi      # 0x8c30
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_O2/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 0x5323(%rip), %esi      # 0xc834
incl %esi
movl %esi, 0x531b(%rip)      # 0xc834
testq %rdi, %rdi
je 0x752e
leaq 0x170b(%rip), %rdi      # 0x8c30
xorl %eax, %eax
callq 0x20f0
jmp 0x7553
leaq 0x16f7(%rip), %rdi      # 0x8c2c
xorl %eax, %eax
callq 0x20f0
leaq 0x17ac(%rip), %rdi      # 0x8cef
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
incl 0x52dd(%rip)            # 0xc830
xorl %eax, %eax
testq %rbx, %rbx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x52c3(%rip), %esi      # 0xc834
incl %esi
movl %esi, 0x52bb(%rip)      # 0xc834
movss %xmm1, -0x10(%rbp)
movss %xmm0, -0xc(%rbp)
ucomiss %xmm1, %xmm0
jne 0x758a
jnp 0x75ba
leaq 0x169b(%rip), %rdi      # 0x8c2c
xorl %eax, %eax
callq 0x20f0
cvtss2sd -0xc(%rbp), %xmm0
cvtss2sd -0x10(%rbp), %xmm1
leaq 0x1786(%rip), %rdi      # 0x8d2f
movl %ebx, %esi
movb $0x2, %al
callq 0x20f0
incl 0x5278(%rip)            # 0xc830
jmp 0x75c8
leaq 0x166f(%rip), %rdi      # 0x8c30
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_O2/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 %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movl 0x5099(%rip), %esi      # 0xc834
incl %esi
movl %esi, 0x5091(%rip)      # 0xc834
cmpq %rcx, %rdx
jne 0x77ca
movq %r12, %rdi
movl %esi, -0x30(%rbp)
movq %r14, %rsi
movq %rbx, %rdx
movq %r8, %r15
callq 0x2220
movl -0x30(%rbp), %esi
movq %r15, %r8
testl %eax, %eax
je 0x78ba
leaq 0x145b(%rip), %rdi      # 0x8c2c
movq %r13, %r15
movq %rbx, %r13
xorl %ebx, %ebx
movq %r8, %rdx
xorl %eax, %eax
callq 0x20f0
leaq 0x1591(%rip), %rdi      # 0x8d7b
movl -0x38(%rbp), %esi
xorl %eax, %eax
callq 0x20f0
cmpq %r15, %r13
movq %r15, %rax
cmovaq %r13, %rax
movq %r15, -0x38(%rbp)
movq %r13, -0x30(%rbp)
cmovbq %r13, %r15
movq %rsp, -0x40(%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 %r15d, %r15d
cmovlel %ebx, %r15d
cmpq %rbx, %r15
je 0x784f
movb (%r12,%rbx), %al
cmpb (%r14,%rbx), %al
je 0x784a
movb $0x1, (%r13,%rbx)
incq %rbx
jmp 0x7835
leaq 0x184c(%rip), %rbx      # 0x90a2
movq %rbx, %rdi
callq 0x2080
leaq 0x1831(%rip), %rdi      # 0x9096
callq 0x2080
movq %r12, %rdi
movq %r13, %rsi
movq -0x30(%rbp), %rdx
callq 0x75e1
movq %rbx, %rdi
callq 0x2080
leaq 0x181c(%rip), %rdi      # 0x90a4
callq 0x2080
movq %r14, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
callq 0x75e1
incl 0x4f8e(%rip)            # 0xc830
pushq $0x1
popq %rbx
movq -0x40(%rbp), %rsp
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x136f(%rip), %rdi      # 0x8c30
xorl %ebx, %ebx
movq %r8, %rdx
xorl %eax, %eax
callq 0x20f0
jmp 0x78a9
// File: /workspace/github_c_makefile_star2_O2/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 0x613e
movl %eax, %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x6b6e
testq %rbx, %rbx
je 0x79b0
movq (%rbx), %rcx
cmpb $0x46, %r14b
je 0x79ad
movzbl %r14b, %edx
cmpl $0x54, %edx
je 0x79a8
cmpl $0x66, %edx
je 0x79a4
cmpl $0x69, %edx
jne 0x79b0
movl %eax, (%rcx)
jmp 0x79b0
movb $0x1, (%rcx)
jmp 0x79b0
movb $0x0, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 -0x7a(%rip), %r14       # 0x795f
xorl %r12d, %r12d
cmpq $0x48, %r12
je 0x7af5
leaq 0x47c3(%rip), %rax      # 0xc1b0
movq (%r12,%rax), %r13
leaq 0x1576(%rip), %rdi      # 0x8f6e
movq %r13, %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 %r13, %rsi
callq 0x5e29
pushq $0xb
popq %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x60b8
movl %eax, %edi
leaq 0x1546(%rip), %rsi      # 0x8f85
pushq $0x44
popq %rdx
callq 0x73f8
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x33e4
pushq $0x8
popq %rdi
callq 0x2200
movq %rax, %r15
movq %r13, %rdi
leaq 0x146e(%rip), %rsi      # 0x8eda
callq 0x22d0
testq %rax, %rax
je 0x7a8b
leaq 0x4727(%rip), %rax      # 0xc1a4
movq %rax, (%r15)
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
jmp 0x7ad3
movq %r13, %rdi
leaq 0x135a(%rip), %rsi      # 0x8def
callq 0x22d0
testq %rax, %rax
je 0x7aa8
leaq 0x46fa(%rip), %rax      # 0xc1a0
jmp 0x7ac3
movq %r13, %rdi
leaq 0x1483(%rip), %rsi      # 0x8f35
callq 0x22d0
testq %rax, %rax
je 0x7aeb
leaq 0x46e5(%rip), %rax      # 0xc1a8
movq %rax, (%r15)
movq %rbx, %rdi
movq %r13, %rsi
leaq -0x174(%rip), %rdx      # 0x795f
movq %r15, %rcx
callq 0x33e4
addq $0x8, %r12
leaq -0x187(%rip), %r14      # 0x795f
jmp 0x79dc
movq %r15, %rdi
callq 0x2030
jmp 0x7adb
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8de1(%rip), %r15      # 0x9ff8
movq (%r15), %rdi
leaq 0x4de3(%rip), %rsi      # 0x6004
xorl %eax, %eax
callq 0x1090
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10e0
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_O2/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 0x12ad
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 0x4d3c(%rip), %rdi      # 0x6010
movq %r10, %rcx
callq 0x11fc
pushq $0x1
popq %rdi
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O2/ShinyaKato[P]skcc/utf8.c
// Function: count_bytes
int count_bytes(unsigned char c) {
  int bytes;

  if(0x00 <= c && c <= 0x7F) { // 1-byte character
    bytes = 1;
  } else if(0x80 <= c && c <= 0xC1) { // invalid sequence (not first byte)
    bytes = -1;
  } else if(0xC2 <= c && c <= 0xDF) { // 2-bytes character
    bytes = 2;
  } else if(0xE0 <= c && c <= 0xEF) { // 3-bytes character
    bytes = 3;
  } else if(0xF0 <= c && c <= 0xF7) { // 4-bytes character
    bytes = 4;
  } else if(0xF8 <= c && c <= 0xFB) { // 5-bytes character
    bytes = -1;
  } else if(0xFC <= c && c <= 0xFD) { // 6-bytes character
    bytes = -1;
  } else if(c == 0xFE) { // invalid sequence
    bytes = -1;
  } else if(c == 0xFF) { // EOF
    bytes = 0;
  }

  return bytes;
}

// Assembly:
testb %dil, %dil
js 0x1411
pushq $0x1
jmp 0x1437
cmpb $-0x3e, %dil
jae 0x141b
pushq $-0x1
jmp 0x1437
cmpb $-0x20, %dil
jae 0x1425
pushq $0x2
jmp 0x1437
cmpb $-0x10, %dil
jae 0x142f
pushq $0x3
jmp 0x1437
cmpb $-0x8, %dil
jae 0x1439
pushq $0x4
popq %rax
retq
xorl %eax, %eax
cmpb $-0x1, %dil
setne %al
negl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1461
cmpl $0x1, %edi
jne 0x146a
pushq $0x1
popq %rax
retq
cmpl $0xc2, %r8d
jae 0x146b
retq
movq %rdi, %rcx
shrq $0x28, %rcx
cmpl $0xdf, %r8d
ja 0x1495
cmpl $0x2, %edi
jne 0x146a
testb $0x1e, %dl
jne 0x146a
andl $0xfe, %ecx
addl $-0x80, %ecx
cmpl $0x42, %ecx
jb 0x145d
jmp 0x146a
movq %rdi, %rsi
shrq $0x30, %rsi
cmpl $0xef, %r8d
ja 0x14da
cmpl $0x3, %edi
jne 0x146a
movl %ecx, %edi
andl $0xfe, %edi
addl $-0x80, %edi
cmpl $0x41, %edi
ja 0x146a
andl $0xfe, %esi
addl $-0x80, %esi
cmpl $0x41, %esi
ja 0x146a
testb $0xf, %dl
sete %dl
testb $0x20, %cl
sete %cl
orb %dl, %cl
jne 0x145d
jmp 0x146a
cmpl $0xf7, %r8d
ja 0x1524
cmpl $0x4, %edi
jne 0x146a
andl $0xfe, %ecx
addl $-0x80, %ecx
cmpl $0x41, %ecx
ja 0x146a
movabsq $-0x3e00000000000001, %rcx # imm = 0xC1FFFFFFFFFFFFFF
cmpq %rcx, %rdi
jg 0x146a
andl $0xfe, %esi
addl $-0x80, %esi
cmpl $0x42, %esi
jb 0x145d
jmp 0x146a
xorl $0xff, %r8d
orl %edi, %r8d
je 0x145d
jmp 0x146a
// File: /workspace/github_c_makefile_star2_O2/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
movl %edi, %ecx
testl %ecx, %ecx
jle 0x1550
incl %eax
shrl %ecx
jmp 0x1546
cmpl $0x8, %eax
jae 0x1560
movl %edi, %eax
pushq $0x1
popq %rcx
xorl %edi, %edi
xorl %esi, %esi
jmp 0x1580
cmpl $0xb, %eax
ja 0x15ab
movl %edi, %eax
shrl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
andl $0x3f, %edi
orl $0x80, %edi
pushq $0x2
popq %rcx
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 0x15df
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
pushq $0x3
popq %rcx
xorl %r8d, %r8d
jmp 0x161a
cmpl $0x15, %eax
ja 0x1622
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
pushq $0x4
popq %rcx
movq %r9, %rdi
jmp 0x1583
movq 0x8a67(%rip), %rax      # 0xa090
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 0x8a4e(%rip), %dl       # 0xa098
jmp 0x1583
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1408
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x173f
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x16dd
movq 0x8(%rbx), %rcx
leaq 0x495e(%rip), %rdi      # 0x602a
leaq 0x495e(%rip), %rdx      # 0x6031
pushq $0x22
popq %rsi
xorl %eax, %eax
callq 0x1252
movslq %ebp, %r14
pushq $0x5
popq %r15
leaq -0x4(%r15), %rax
cmpq %r14, %rax
jge 0x16ff
movq (%rbx), %rdi
callq 0x1060
movb %al, 0x8(%rsp,%r15)
incq %r15
jmp 0x16e4
movq 0x8(%rsp), %r14
movl 0x10(%rsp), %esi
movq %r14, %rdi
callq 0x1445
testl %eax, %eax
jne 0x1730
movq 0x8(%rbx), %rcx
leaq 0x490b(%rip), %rdi      # 0x602a
leaq 0x490b(%rip), %rdx      # 0x6031
pushq $0x2e
popq %rsi
xorl %eax, %eax
callq 0x1252
movslq %r14d, %rax
movb $0x0, 0xc(%rsp,%rax)
leaq 0x8(%rsp), %rax
jmp 0x1746
leaq 0x894a(%rip), %rax      # 0xa090
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_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1c(%rdi), %r14
movl 0x18(%rdi), %ecx
cmpl $0x2, %ecx
jg 0x1799
movslq %ecx, %rax
imulq $0xc, %rax, %r15
movq %rbx, %rdi
callq 0x168d
movq %rax, (%r14,%r15)
movb %dl, 0x8(%r14,%r15)
movslq 0x18(%rbx), %rcx
imulq $0xc, %rcx, %rax
cmpl $0x0, (%r14,%rax)
je 0x1799
incl %ecx
movl %ecx, 0x18(%rbx)
jmp 0x1766
cmpl $0x3, %ecx
je 0x17b5
testl %ecx, %ecx
jne 0x17f6
leaq 0x88e7(%rip), %rcx      # 0xa090
movq (%rcx), %rax
movb 0x8(%rcx), %dl
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x3f, 0x20(%rbx)
jne 0x17f6
cmpb $0x3f, 0x2c(%rbx)
jne 0x17f6
movb 0x38(%rbx), %al
xorl %edx, %edx
leaq 0x48c6(%rip), %rsi      # 0x6093
cmpq $0x9, %rdx
je 0x17f6
leaq 0x1(%rdx), %rdi
cmpb (%rdx,%rsi), %al
movq %rdi, %rdx
jne 0x17cd
leaq 0x48b6(%rip), %rax      # 0x609c
movzbl -0x1(%rdi,%rax), %edi
callq 0x1539
andl $0x0, 0x18(%rbx)
jmp 0x17af
movq 0x1c(%rbx), %rax
movb 0x24(%rbx), %dl
decl %ecx
movl %ecx, 0x18(%rbx)
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
imulq $0xc, %rcx, %rcx
addq $0x28, %rbx
cmpq %rsi, %rcx
je 0x17af
movl 0x8(%rbx,%rsi), %edi
movl %edi, -0x4(%rbx,%rsi)
movq (%rbx,%rsi), %rdi
movq %rdi, -0xc(%rbx,%rsi)
addq $0xc, %rsi
jmp 0x1811