LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x5b40
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5b90
movq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x755c
movq 0x8a92(%rip), %rax      # 0xffd8
movq (%rax), %rdi
leaq 0x516c(%rip), %rsi      # 0xc6bc
movb $0x0, %al
callq 0x21b0
jmp 0x762f
cmpl $0x3, -0x40(%rbp)
jne 0x757a
movq -0x60(%rbp), %rdi
callq 0x2090
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4c(%rax)
jmp 0x7595
movq 0x8a57(%rip), %rax      # 0xffd8
movq (%rax), %rdi
movl -0x40(%rbp), %edx
leaq 0x5167(%rip), %rsi      # 0xc6f5
movb $0x0, %al
callq 0x21b0
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5b90
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x75f6
movq 0x89f5(%rip), %rax      # 0xffd8
movq (%rax), %rdi
leaq 0x5134(%rip), %rsi      # 0xc721
movb $0x0, %al
callq 0x21b0
jmp 0x762f
cmpl $0x3, -0x40(%rbp)
jne 0x7614
movq -0x60(%rbp), %rdi
callq 0x2090
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x50(%rax)
jmp 0x762f
movq 0x89bd(%rip), %rax      # 0xffd8
movq (%rax), %rdi
movl -0x40(%rbp), %edx
leaq 0x5135(%rip), %rsi      # 0xc75d
movb $0x0, %al
callq 0x21b0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x8024
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x802a
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8041
movq $0x0, -0x8(%rbp)
jmp 0x80b1
jmp 0x8043
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x25(%rbp)
je 0x805e
cmpl $0x0, -0x18(%rbp)
setge %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x8067
jmp 0x8099
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8080
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80b1
movl -0x20(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8043
cmpl $0x0, -0x1c(%rbp)
je 0x80a9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x80b1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
callq 0x2030
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x8263
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x81ad
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x2030
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movslq -0x4(%rbp), %rdx
imulq $0x58, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movl 0x10(%rcx), %ecx
cmpq %rcx, %rax
jae 0x818d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8134
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x4(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2030
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x80df
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/schema.c
// Function: sm_get
schema_handle_t sm_get(schema_t sch, uri_t u)
{
    schema_handle_t invalid;
    memset(&invalid, 0, sizeof(invalid));
    invalid.flag = 0xdeadbeef;
    //printf("Getting a handle(%s)...\n", u);
    for(int i=0; i<sch.elements; ++i)
        if(match_path(u, sch.handles[i].pattern))
            return sch.handles[i];
    if(!(strstr(u, "VoicePar") && strstr(u, "Enabled")))
        printf("[WARNING:osc-bridge] Invalid Handle \"%s\"...\n", u);
    return invalid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x2130
movl $0xdeadbeef, -0x60(%rbp) # imm = 0xDEADBEEF
movl $0x0, -0x64(%rbp)
movq -0x70(%rbp), %rcx
movl -0x64(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x831e
movq -0x70(%rbp), %rax
movq -0x8(%rbp), %rdi
movq 0x8(%rax), %rax
movslq -0x64(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x8380
cmpl $0x0, %eax
je 0x8311
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x64(%rbp), %rax
imulq $0x58, %rax, %rax
addq %rax, %rsi
movl $0x58, %edx
callq 0x21e0
jmp 0x836e
jmp 0x8313
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x82bd
movq -0x8(%rbp), %rdi
leaq 0x4566(%rip), %rsi      # 0xc88f
callq 0x22b0
cmpq $0x0, %rax
je 0x834a
movq -0x8(%rbp), %rdi
leaq 0x4559(%rip), %rsi      # 0xc898
callq 0x22b0
cmpq $0x0, %rax
jne 0x835c
movq -0x8(%rbp), %rsi
leaq 0x454b(%rip), %rdi      # 0xc8a0
movb $0x0, %al
callq 0x20e0
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x58, %edx
callq 0x21e0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8761
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x8761
jmp 0x8780
leaq 0x4518(%rip), %rdi      # 0xcc80
leaq 0x451d(%rip), %rsi      # 0xcc8c
movl $0xd, %edx
leaq 0x451f(%rip), %rcx      # 0xcc9a
callq 0x2120
jmp 0x8782
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpb $0x0, 0x1(%rax)
je 0x8799
jmp 0x8782
jmp 0x879b
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
cmpb $0x0, 0x1(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x87b9
jmp 0x87bb
jmp 0x879b
movq -0x8(%rbp), %rax
addq $0x1, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8740
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0x883d
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5d, %ecx
movb %al, -0x15(%rbp)
je 0x8825
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x87f0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x87d0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jae 0x8879
jmp 0x8898
leaq 0x444a(%rip), %rdi      # 0xccca
leaq 0x4405(%rip), %rsi      # 0xcc8c
movl $0x45, %edx
leaq 0x4459(%rip), %rcx      # 0xccec
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x8740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x88bd
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5d, %eax
jne 0x88cb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x88fd
cmpl $0x0, -0xc(%rbp)
je 0x88da
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x88e6
movq -0x18(%rbp), %rax
movb (%rax), %al
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x88fd
jmp 0x88a5
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8f5c
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0xa510
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x8f33
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: arg_start
static unsigned arg_start(const char *msg_)
{
    const uint8_t *msg = (const uint8_t*)msg_;
    //Iterate to the right position
    const uint8_t *args = (const uint8_t*) rtosc_argument_string(msg_);
    const uint8_t *aligned_ptr = args-1;
    const uint8_t *arg_pos = args;

    while(*++arg_pos);
    //Alignment
    arg_pos += 4-(arg_pos-aligned_ptr)%4;
    return arg_pos-msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
cmpb $0x0, 0x1(%rax)
je 0x987c
jmp 0x9865
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl $0x4, %ecx
cqto
idivq %rcx
movl $0x4, %eax
subq %rdx, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq 0x338a(%rip), %rax      # 0xcc68
movq %rax, (%rdi)
movq 0x3388(%rip), %rax      # 0xcc70
movq %rax, 0x8(%rdi)
movq 0x3385(%rip), %rax      # 0xcc78
movq %rax, 0x10(%rdi)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, (%rdi)
cmpb $0x0, (%rdi)
je 0x993a
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movsbl (%rax), %esi
callq 0x99a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
callq 0x97e0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movsbl -0x19(%rbp), %esi
callq 0x9c70
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %esi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdx
movslq %esi, %rsi
addq %rsi, %rdx
movq %rdx, 0x8(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: arg_off
static unsigned arg_off(const char *msg, unsigned idx)
{
    if(!has_reserved(rtosc_type(msg,idx)))
        return 0;

    //Iterate to the right position
    const uint8_t *args = (const uint8_t*) rtosc_argument_string(msg);
    const uint8_t *aligned_ptr = args-1;
    const uint8_t *arg_pos = args;

    while(*++arg_pos);
    //Alignment
    arg_pos += 4-(arg_pos-((uint8_t*)aligned_ptr))%4;

    //ignore any leading '[' or ']'
    while(*args == '[' || *args == ']')
        ++args;

    while(idx--) {
        char type = *args++;
        if(type == '[' || type == ']')
            idx++;//not a valid arg idx
        else
            arg_pos += arg_size(arg_pos, type);
    }
    return arg_pos-(uint8_t*)msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8850
movsbl %al, %edi
callq 0xa510
cmpl $0x0, %eax
jne 0x9ef4
movl $0x0, -0x4(%rbp)
jmp 0x9ff8
movq -0x10(%rbp), %rdi
callq 0x8740
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x30(%rbp)
cmpb $0x0, 0x1(%rax)
je 0x9f2c
jmp 0x9f15
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl $0x4, %ecx
cqto
idivq %rcx
movl $0x4, %eax
subq %rdx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x5b, %ecx
movb %al, -0x32(%rbp)
je 0x9f72
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5d, %eax
sete %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x9f7b
jmp 0x9f89
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x9f51
jmp 0x9f8b
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x9fea
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x5b, %eax
je 0x9fc1
movsbl -0x31(%rbp), %eax
cmpl $0x5d, %eax
jne 0x9fcc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9fe8
movq -0x30(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0x9c70
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x9f8b
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %edi
addl $0x0, %edi
movq -0x8(%rbp), %rsi
callq 0xa3c0
movzbl %al, %eax
shll $0x18, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
movq -0x8(%rbp), %rsi
callq 0xa3c0
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %edi
addl $0x2, %edi
movq -0x8(%rbp), %rsi
callq 0xa3c0
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %edi
addl $0x3, %edi
movq -0x8(%rbp), %rsi
callq 0xa3c0
movb %al, %cl
movl -0x14(%rbp), %eax
movzbl %cl, %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xa4d1
movl -0x10(%rbp), %eax
addl $0x4, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xa4d3
cmpl $0x0, -0x10(%rbp)
jne 0xa44a
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
ja 0xa4fd
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xa504
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xa504
movl -0x20(%rbp), %eax
movl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: has_reserved
static int has_reserved(char type)
{
    switch(type)
    {
        case 'i'://official types
        case 's':
        case 'b':
        case 'f':

        case 'h'://unofficial
        case 't':
        case 'd':
        case 'S':
        case 'r':
        case 'm':
        case 'c':
            return 1;
        case 'T':
        case 'F':
        case 'N':
        case 'I':
        case '[':
        case ']':
            return 0;
    }

    //Should not happen
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x46, %eax
je 0xa5ac
jmp 0xa52c
movl -0xc(%rbp), %eax
subl $0x49, %eax
je 0xa5ac
jmp 0xa536
movl -0xc(%rbp), %eax
subl $0x4e, %eax
je 0xa5ac
jmp 0xa540
movl -0xc(%rbp), %eax
subl $0x53, %eax
je 0xa5a3
jmp 0xa54a
movl -0xc(%rbp), %eax
subl $0x54, %eax
je 0xa5ac
jmp 0xa554
movl -0xc(%rbp), %eax
subl $0x5b, %eax
je 0xa5ac
jmp 0xa55e
movl -0xc(%rbp), %eax
subl $0x5d, %eax
je 0xa5ac
jmp 0xa568
movl -0xc(%rbp), %eax
addl $-0x62, %eax
subl $0x3, %eax
jb 0xa5a3
jmp 0xa575
movl -0xc(%rbp), %eax
subl $0x66, %eax
je 0xa5a3
jmp 0xa57f
movl -0xc(%rbp), %eax
addl $-0x68, %eax
subl $0x2, %eax
jb 0xa5a3
jmp 0xa58c
movl -0xc(%rbp), %eax
subl $0x6d, %eax
je 0xa5a3
jmp 0xa596
movl -0xc(%rbp), %eax
addl $-0x72, %eax
subl $0x2, %eax
ja 0xa5b5
jmp 0xa5a3
movl $0x1, -0x4(%rbp)
jmp 0xa5bc
movl $0x0, -0x4(%rbp)
jmp 0xa5bc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xa635
movb $0x0, -0x1(%rbp)
jmp 0xa734
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0xa69b
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa65b
jmp 0xa69b
callq 0x22d0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0xa684
movb $0x0, -0x1(%rbp)
jmp 0xa734
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa644
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa6eb
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xa6d1
jmp 0xa6eb
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xa6b9
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
cmpq $0x4, %rax
jbe 0xa6ff
movb $0x0, -0x1(%rbp)
jmp 0xa734
movq -0x38(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xa713
movb $0x0, -0x1(%rbp)
jmp 0xa734
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa5d0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0xa781
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2130
movq -0x8(%rbp), %rdi
leaq 0x25de(%rip), %rsi      # 0xcd9e
callq 0x2040
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa900
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa8e1
leaq -0x40(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0xa85c
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0xa879
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq $-0x1, %rsi
callq 0xa5d0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rax
movl %eax, %esi
callq 0xa9d0
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x21e0
movq -0x58(%rbp), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xa815
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x21(%rbp)
jae 0xaa7c
movq -0x18(%rbp), %rdi
callq 0xaae0
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xaa85
jmp 0xaac8
movq -0x18(%rbp), %rdi
callq 0xaae0
movl %eax, %ecx
shrl $0x2, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
cmpq -0x10(%rbp), %rax
jbe 0xaaba
jmp 0xaac8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xaa54
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: extract_uint32
static uint32_t extract_uint32(const uint8_t *arg_pos)
{
    uint32_t arg = 0;
    arg |= (((uint32_t)*arg_pos++) << 24);
    arg |= (((uint32_t)*arg_pos++) << 16);
    arg |= (((uint32_t)*arg_pos++) << 8);
    arg |= (((uint32_t)*arg_pos++));
    return arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shll $0x18, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shll $0x10, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shll $0x8, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
je 0xaba8
movq -0x18(%rbp), %rdi
callq 0xaae0
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xabb1
jmp 0xabe1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaae0
movl %eax, %ecx
shrl $0x2, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xab83
movl -0xc(%rbp), %eax
cmpq -0x20(%rbp), %rax
jne 0xabf8
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0xac00
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0xac00
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
je 0xac60
movq -0x18(%rbp), %rdi
callq 0xaae0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xac69
jmp 0xaca8
movq -0x18(%rbp), %rdi
callq 0xaae0
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaae0
movl %eax, %ecx
shrl $0x2, %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xac3b
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/rtosc/rtosc.c
// Function: extract_uint64
static uint64_t extract_uint64(const uint8_t *arg_pos)
{
    uint64_t arg = 0;
    arg |= (((uint64_t)*arg_pos++) << 56);
    arg |= (((uint64_t)*arg_pos++) << 48);
    arg |= (((uint64_t)*arg_pos++) << 40);
    arg |= (((uint64_t)*arg_pos++) << 32);
    arg |= (((uint64_t)*arg_pos++) << 24);
    arg |= (((uint64_t)*arg_pos++) << 16);
    arg |= (((uint64_t)*arg_pos++) << 8);
    arg |= (((uint64_t)*arg_pos++));
    return arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x38, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x30, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x28, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x20, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x18, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x10, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shlq $0x8, %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl 0x59e9(%rip), %eax      # 0x10824
addl $0x1, %eax
movl %eax, 0x59e0(%rip)      # 0x10824
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xae9b
movl 0x59c3(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x2038(%rip), %rdi      # 0xcea4
movb $0x0, %al
callq 0x20e0
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x2034(%rip), %rdi      # 0xceb7
movb $0x0, %al
callq 0x20e0
movl 0x5990(%rip), %eax      # 0x10820
addl $0x1, %eax
movl %eax, 0x5987(%rip)      # 0x10820
jmp 0xaeb3
movl 0x5983(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1ffc(%rip), %rdi      # 0xcea8
movb $0x0, %al
callq 0x20e0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movb %dil, %sil
movb %sil, -0x1(%rbp)
movb %al, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl 0x5942(%rip), %eax      # 0x10824
addl $0x1, %eax
movl %eax, 0x5939(%rip)      # 0x10824
movsbl -0x1(%rbp), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xaf48
movl 0x5918(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1f8d(%rip), %rdi      # 0xcea4
movb $0x0, %al
callq 0x20e0
movsbl -0x1(%rbp), %esi
movsbl -0x2(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x1fb9(%rip), %rdi      # 0xcee9
movb $0x0, %al
callq 0x20e0
movl 0x58e3(%rip), %eax      # 0x10820
addl $0x1, %eax
movl %eax, 0x58da(%rip)      # 0x10820
jmp 0xaf60
movl 0x58d6(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1f4f(%rip), %rdi      # 0xcea8
movb $0x0, %al
callq 0x20e0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl 0x589c(%rip), %eax      # 0x10824
addl $0x1, %eax
movl %eax, 0x5893(%rip)      # 0x10824
cmpl $0x0, -0x4(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xafe2
movl 0x5876(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1eeb(%rip), %rdi      # 0xcea4
movb $0x0, %al
callq 0x20e0
movl -0x14(%rbp), %esi
leaq 0x1f51(%rip), %rdi      # 0xcf1b
movb $0x0, %al
callq 0x20e0
movl 0x5849(%rip), %eax      # 0x10820
addl $0x1, %eax
movl %eax, 0x5840(%rip)      # 0x10820
jmp 0xaffa
movl 0x583c(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1eb5(%rip), %rdi      # 0xcea8
movb $0x0, %al
callq 0x20e0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl 0x57b7(%rip), %eax      # 0x10824
addl $0x1, %eax
movl %eax, 0x57ae(%rip)      # 0x10824
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xb0ce
movl 0x5792(%rip), %esi      # 0x10824
movq -0x18(%rbp), %rdx
leaq 0x1e07(%rip), %rdi      # 0xcea4
movb $0x0, %al
callq 0x20e0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x1e7b(%rip), %rdi      # 0xcf31
movb $0x0, %al
callq 0x20e0
movl 0x575d(%rip), %eax      # 0x10820
addl $0x1, %eax
movl %eax, 0x5754(%rip)      # 0x10820
jmp 0xb0e6
movl 0x5750(%rip), %esi      # 0x10824
movq -0x18(%rbp), %rdx
leaq 0x1dc9(%rip), %rdi      # 0xcea8
movb $0x0, %al
callq 0x20e0
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl 0x571b(%rip), %eax      # 0x10824
addl $0x1, %eax
movl %eax, 0x5712(%rip)      # 0x10824
cmpq $0x0, -0x8(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xb164
movl 0x56f4(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1d69(%rip), %rdi      # 0xcea4
movb $0x0, %al
callq 0x20e0
movl -0x14(%rbp), %esi
leaq 0x1e1b(%rip), %rdi      # 0xcf67
movb $0x0, %al
callq 0x20e0
movl 0x56c7(%rip), %eax      # 0x10820
addl $0x1, %eax
movl %eax, 0x56be(%rip)      # 0x10820
jmp 0xb17c
movl 0x56ba(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1d33(%rip), %rdi      # 0xcea8
movb $0x0, %al
callq 0x20e0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl 0x5675(%rip), %eax      # 0x10824
addl $0x1, %eax
movl %eax, 0x566c(%rip)      # 0x10824
movss -0x4(%rbp), %xmm0
ucomiss -0x8(%rbp), %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0xb223
movl 0x5647(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1cbc(%rip), %rdi      # 0xcea4
movb $0x0, %al
callq 0x20e0
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movl -0x14(%rbp), %esi
leaq 0x1d9c(%rip), %rdi      # 0xcfa7
movb $0x2, %al
callq 0x20e0
movl 0x5608(%rip), %eax      # 0x10820
addl $0x1, %eax
movl %eax, 0x55ff(%rip)      # 0x10820
jmp 0xb23b
movl 0x55fb(%rip), %esi      # 0x10824
movq -0x10(%rbp), %rdx
leaq 0x1c74(%rip), %rdi      # 0xcea8
movb $0x0, %al
callq 0x20e0
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x8850
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x9e60
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb76a
jmp 0xb7c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x69, %eax
jne 0xb789
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0xb7c9
movsbl -0x11(%rbp), %eax
cmpl $0x54, %eax
jne 0xb79b
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0xb7c7
movsbl -0x11(%rbp), %eax
cmpl $0x46, %eax
jne 0xb7ad
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0xb7c5
movsbl -0x11(%rbp), %eax
cmpl $0x66, %eax
jne 0xb7c3
movss -0x28(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, (%rax)
jmp 0xb7c5
jmp 0xb7c7
jmp 0xb7c9
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq 0xcde6(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq 0x8ddc(%rip), %rsi      # 0xa004
movb $0x0, %al
callq 0x1080
movq 0xcdc2(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10d0
movq 0xcdab(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x9818(%rip), %rsi      # 0xaa6f
movb $0x0, %al
callq 0x1080
movq 0xcd93(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x9800(%rip), %rsi      # 0xaa6f
movb $0x0, %al
callq 0x1080
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x12b8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq 0x8cfe(%rip), %rdi      # 0xa010
callq 0x11f0
leaq -0x30(%rbp), %rax
movl $0x1, %edi
callq 0x10e0
nopw %cs:(%rax,%rax)