LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: osc_send
void osc_send(bridge_t *br, const char *message)
{
    size_t   len   = rtosc_message_length(message, -1);
    char     *copy = (char*)malloc(len);
    memcpy(copy, message, len);
    do_send(br, copy, len);
    //printf("osc sent...<%s>?\n", message);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x6fcc
movq %rax, %r15
movq %rax, %rdi
callq 0x2200
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21e0
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2689
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: do_send
static void do_send(bridge_t *br, char *buffer, unsigned len)
{
    if(br->frame_messages >= BR_RATE_LIMIT) {
        br->rlimit_len++;
        br->rlimit = (char**)realloc(br->rlimit, sizeof(char**)*br->rlimit_len);
        br->rlimit[br->rlimit_len-1] = buffer;
        return;
    }
    br->frame_messages++;
    req_t *request = (req_t*)malloc(sizeof(req_t));
    request->data  = buffer;
    uv_buf_t buf   = uv_buf_init((char*)buffer, len);

    struct sockaddr_in send_addr;
    uv_ip4_addr(br->address, br->port, &send_addr);
    uv_udp_send(&request->send_req, &br->socket, &buf, 1, (const struct sockaddr *)&send_addr, send_cb);
    uv_run(br->loop, UV_RUN_NOWAIT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xfc(%rdi), %eax
cmpl $0x80, %eax
jl 0x26e5
movslq 0x12c(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x12c(%rbx)
movq 0x118(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2240
movq %rax, 0x118(%rbx)
movslq 0x12c(%rbx), %rcx
movq %r14, -0x8(%rax,%rcx,8)
jmp 0x275a
movl %edx, %r15d
incl %eax
movl %eax, 0xfc(%rbx)
movl $0x148, %edi            # imm = 0x148
callq 0x2200
movq %rax, %r12
movq %r14, 0x140(%rax)
movq %r14, %rdi
movl %r15d, %esi
callq 0x20a0
leaq -0x30(%rbp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movq 0xf0(%rbx), %rdi
movl 0xf8(%rbx), %esi
leaq -0x40(%rbp), %r15
movq %r15, %rdx
callq 0x20e0
leaq 0x8(%rbx), %rsi
leaq 0x1913(%rip), %r9       # 0x4051
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %r8
callq 0x2150
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x2310
addq $0x20, %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/bridge.c
// Function: br_create
bridge_t *br_create(uri_t uri)
{
    bridge_t *br = (bridge_t*)calloc(1,sizeof(bridge_t));

    br->loop = (uv_loop_t*)calloc(1, sizeof(uv_loop_t));
    uv_loop_init(br->loop);

    uv_udp_init(br->loop, &br->socket);
    int no_collide = rand()%1000;
    for(int offset=0; offset < 1000; ++offset) {
        struct sockaddr_in recv_addr;
        recv_addr.sin_family = AF_INET;
        recv_addr.sin_port = htons(1338+(offset+no_collide)%1000);
        recv_addr.sin_addr.s_addr = INADDR_ANY;
        if(!uv_udp_bind(&br->socket, (const struct sockaddr *)&recv_addr, 0))
            break;
    }
    br->socket.data = br;

    uv_udp_recv_start(&br->socket, alloc_buffer, on_read);

    //parse the url to read
    if(strstr(uri, "osc.udp://") != uri) {
        fprintf(stderr, "[ERROR] Unknown protocol in '%s'\n", uri);
        fprintf(stderr, "[ERROR] Try something like osc.udp://localhost:1234\n");
        exit(1);
    }
    uri = uri+10;
    char *tmp = br->address = strdup(uri);
    while(*tmp && *tmp != ':') ++tmp;
    if(*tmp == ':')
        *tmp++ = 0;

    br->port = atoi(tmp);

    return br;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x30(%rbp)
pushq $0x1
popq %r15
movl $0x138, %esi            # imm = 0x138
movq %r15, %rdi
callq 0x2180
movq %rax, %rbx
movl $0x350, %esi            # imm = 0x350
movq %r15, %rdi
callq 0x2180
movq %rax, %r12
movq %rax, (%rbx)
movq %rax, %rdi
callq 0x2160
movq %rbx, -0x38(%rbp)
movq %rbx, %r15
addq $0x8, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x21d0
callq 0x22e0
movl $0x3e8, %r14d           # imm = 0x3E8
cltd
idivl %r14d
movl %edx, %r12d
xorl %ebx, %ebx
leaq -0x48(%rbp), %r13
cmpl $0x3e8, %ebx            # imm = 0x3E8
je 0x2814
movw $0x2, -0x48(%rbp)
leal (%r12,%rbx), %eax
cltd
idivl %r14d
addl $0x53a, %edx            # imm = 0x53A
rolw $0x8, %dx
movw %dx, -0x46(%rbp)
andl $0x0, -0x44(%rbp)
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2190
incl %ebx
testl %eax, %eax
jne 0x27d9
movq -0x38(%rbp), %rbx
movq %rbx, 0x8(%rbx)
leaq 0xab(%rip), %rsi        # 0x28ce
leaq -0x40e(%rip), %rdx      # 0x241c
movq %r15, %rdi
callq 0x2210
leaq 0x581f(%rip), %rsi      # 0x8058
pushq $0xa
popq %rdx
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2050
testl %eax, %eax
jne 0x2896
addq $0xa, %r14
movq %r14, %rdi
callq 0x22c0
movq %rax, 0xf0(%rbx)
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x2876
cmpl $0x3a, %ecx
je 0x2870
incq %rax
jmp 0x285f
movb $0x0, (%rax)
incq %rax
movq %rax, %rdi
callq 0x2280
movl %eax, 0xf8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x975b(%rip), %rbx      # 0xbff8
movq (%rbx), %rdi
leaq 0x57bc(%rip), %rsi      # 0x8063
movq %r14, %rdx
xorl %eax, %eax
callq 0x21b0
movq (%rbx), %rcx
leaq 0x57ca(%rip), %rdi      # 0x8085
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
callq 0x22b0
pushq $0x1
popq %rdi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: declone_vec_value
static void
declone_vec_value(const char *type, rtosc_arg_t *val)
{
    int n = strlen(type);
    for(int i=0; i<n; ++i)
        declone_value(type[i], val[i]);
    free(val);
    free((void*)type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r15
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
leaq 0x8(%r14), %r13
cmpq %r12, %r15
je 0x2ad7
cmpb $0x62, (%rbx,%r12)
jne 0x2ace
movq (%r13), %rdi
callq 0x2030
incq %r12
addq $0x10, %r13
jmp 0x2ab9
movq %r14, %rdi
callq 0x2030
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/src/bridge.c
// Function: br_get_schema
schema_t br_get_schema(bridge_t *br, uri_t uri)
{
    (void) uri;
    schema_t sch;

    //printf("[debug] loading json file\n");
    FILE *f = fopen("schema/test.json", "r");
    if(!f && br->search_path) {
        char tmp[256];
        snprintf(tmp, sizeof(tmp), "%s%s", br->search_path, "schema/test.json");
        f = fopen(tmp, "r");
    }
    if(!f)
        f = fopen("src/osc-bridge/schema/test.json", "r");
    if(!f) {
        printf("[ERROR:Zyn] schema/test.json file is missing.\n");
        printf("[ERROR:Zyn] Please check your installation for problems\n");
        exit(1);
    }
    assert(f && "opening json file");
    fseek(f, 0, SEEK_END);
    size_t len = ftell(f);
    rewind(f);
    char *json = (char*)calloc(1, len+1);
    fread(json, 1, len, f);
    fclose(f);

    printf("[debug] parsing json file\n");
    parse_schema(json, &sch);
    printf("[debug] json parsed succesfully\n");
    sch.json = json;


	return sch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x5655(%rip), %rdi      # 0x816b
leaq 0x5cf9(%rip), %rsi      # 0x8816
callq 0x2270
testq %rax, %rax
jne 0x2b87
movq 0xe8(%r15), %rcx
testq %rcx, %rcx
je 0x2b6b
leaq 0x561d(%rip), %rdx      # 0x8157
leaq 0x562a(%rip), %r8       # 0x816b
leaq -0x130(%rbp), %r14
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
leaq 0x5cb8(%rip), %rsi      # 0x8816
movq %r14, %rdi
callq 0x2270
testq %rax, %rax
jne 0x2b87
leaq 0x55ea(%rip), %rdi      # 0x815c
leaq 0x5c9d(%rip), %rsi      # 0x8816
callq 0x2270
testq %rax, %rax
je 0x2c11
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2230
movq %r14, %rdi
callq 0x21c0
movq %rax, %r15
movq %r14, %rdi
callq 0x2100
leaq 0x1(%r15), %rsi
pushq $0x1
popq %r12
movq %r12, %rdi
callq 0x2180
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2090
movq %r14, %rdi
callq 0x20c0
leaq 0x58e5(%rip), %rdi      # 0x84c2
callq 0x2080
movq %r13, %rdi
movq %rbx, %rsi
callq 0x56c0
leaq 0x58e8(%rip), %rdi      # 0x84dc
callq 0x2080
movq %r13, (%rbx)
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5844(%rip), %rdi      # 0x845c
callq 0x2080
leaq 0x5866(%rip), %rdi      # 0x848a
callq 0x2080
pushq $0x1
popq %rdi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_default
void br_default(bridge_t *br, schema_t s, uri_t uri)
{
    schema_handle_t handle = sm_get(s, uri);
    if(!sm_valid(handle))
        return;
    if(handle.type == 'i' && handle.default_)
        br_set_value_int(br, uri, atoi(handle.default_));
    else if(handle.type == 'f' && handle.default_)
        br_set_value_float(br, uri, atof(handle.default_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps 0x10(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x5e29
pushq $0xb
popq %rcx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x60b8
testl %eax, %eax
je 0x2cd1
movb -0x28(%rbp), %al
cmpb $0x69, %al
sete %cl
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2cac
callq 0x2280
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x2cdf
jmp 0x2cd1
testq %rdi, %rdi
setne %cl
cmpb $0x66, %al
sete %al
andb %cl, %al
cmpb $0x1, %al
jne 0x2cd1
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d60
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_value_int
void br_set_value_int(bridge_t *br, uri_t uri, int value)
{
    rtosc_arg_t arg = {.i = value};
    if(cache_set(br, uri, 'i', arg, 1)) {
        char buffer[1024];
        rtosc_message(buffer, 1024, uri, "i", value);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %ecx
pushq $0x69
popq %rdx
pushq $0x1
popq %r9
callq 0x31b4
testl %eax, %eax
je 0x2d50
leaq 0x5476(%rip), %rcx      # 0x8189
leaq -0x420(%rbp), %r12
movl $0x400, %esi            # imm = 0x400
movq %r12, %rdi
movq %r14, %rdx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x619b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x263e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fbc
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_value_float
void br_set_value_float(bridge_t *br, uri_t uri, float value)
{
    rtosc_arg_t arg = {.f = value};
    if(cache_set(br, uri, 'f', arg, 1)) {
        char buffer[1024];
        rtosc_message(buffer, 1024, uri, "f", value);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq %rdi, %rbx
movd %xmm0, -0x1c(%rbp)
movd %xmm0, %ecx
pushq $0x66
popq %rdx
pushq $0x1
popq %r9
callq 0x31b4
testl %eax, %eax
je 0x2dd5
cvtss2sd -0x1c(%rbp), %xmm0
leaq 0x589f(%rip), %rcx      # 0x863a
leaq -0x420(%rbp), %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
movq %r14, %rdx
movb $0x1, %al
callq 0x619b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x263e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fbc
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_array
void br_set_array(bridge_t *br, uri_t uri, char *type, rtosc_arg_t*args)
{
    if(cache_set_vector(br, uri, type, args)) {
        char buffer[1024*8];
        int len = rtosc_amessage(buffer, sizeof(buffer), uri, type, args);
        (void) len;
        //hexdump(buffer, 0, len);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2e5c
testl %eax, %eax
je 0x2e4a
leaq -0x2030(%rbp), %r13
movl $0x2000, %esi           # imm = 0x2000
movq %r13, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x64d1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x263e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fbc
addq $0x2008, %rsp           # imm = 0x2008
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/bridge.c
// Function: cache_set_vector
static int cache_set_vector(bridge_t *br, uri_t uri, char *types, rtosc_arg_t *args)
{
    param_cache_t *line = cache_get(br, uri);
    assert(line);
    line->pending = false;

    int line_size = line->type == 'v' ? strlen(line->vec_type) : 0;

    //If the line is invalid OR
    //the cache isn't a vector field OR
    //the vector fields differ in type OR
    //the vector fields differ in value
    if(!line->valid || line->type != 'v' || strcmp(line->vec_type, types) ||
            memcmp(&line->vec_value, &args, sizeof(args[0])*line_size))
    {
        if(line->type == 'v')
            declone_vec_value(line->vec_type, line->vec_value);
        else
            declone_value(line->type, line->val);

        line->valid     = true;
        line->type      = 'v';
        line->vec_type  = strdup(types);
        line->vec_value = clone_vec_value(types, args);
        line->requests = 0;

        //check if cache line is currently debounced...
        //int debounced = false;
        //for(int i=0; i<br->debounce_len; ++i)
        //    if(!strcmp(br->bounce[i].path, line->path))
        //        debounced = true;

        //if(!debounced)
            run_callbacks(br, line);

        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movq %rcx, -0x40(%rbp)
callq 0x30ae
testq %rax, %rax
je 0x2f9d
movq %rax, %r13
movq %rbx, -0x38(%rbp)
movb 0x8(%rax), %r12b
movl %r12d, %eax
andb $-0x3, %al
movb %al, 0x8(%r13)
movzbl 0x9(%r13), %eax
cmpl $0x62, %eax
je 0x2eff
cmpl $0x76, %eax
jne 0x2f08
movq 0x20(%r13), %rbx
movq %rbx, %rdi
callq 0x20d0
testb $0x1, %r12b
je 0x2ef1
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %r12
callq 0x21a0
testl %eax, %eax
jne 0x2ef1
movq %r12, %rax
movslq %eax, %rdx
shlq $0x4, %rdx
movq %r13, %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
callq 0x2220
testl %eax, %eax
je 0x2f99
movq 0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x2a8f
jmp 0x2f08
movq 0x28(%r13), %rdi
callq 0x2030
orb $0x1, 0x8(%r13)
movb $0x76, 0x9(%r13)
movq %r15, %rdi
callq 0x22c0
movq %r13, -0x30(%rbp)
movq %rax, 0x20(%r13)
movq %r15, %rdi
callq 0x20d0
movslq %eax, %r13
pushq $0x10
popq %rdi
movq %r13, %rsi
callq 0x2180
movq %rax, %rbx
xorl %r12d, %r12d
testl %r13d, %r13d
cmovlel %r12d, %r13d
shlq $0x4, %r13
cmpq %r12, %r13
je 0x2f72
movsbl (%r15), %edi
movq (%r14,%r12), %rsi
movq 0x8(%r14,%r12), %rdx
callq 0x4074
movq %rax, (%rbx,%r12)
movq %rdx, 0x8(%rbx,%r12)
addq $0x10, %r12
incq %r15
jmp 0x2f49
movq -0x30(%rbp), %rsi
movq %rbx, 0x28(%rsi)
andl $0x0, 0x18(%rsi)
movq -0x38(%rbp), %rdi
callq 0x3e0a
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x2f8a
leaq 0x5356(%rip), %rdi      # 0x82fa
leaq 0x51d1(%rip), %rsi      # 0x817c
leaq 0x534d(%rip), %rcx      # 0x82ff
movl $0x95, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: debounce_update
static void debounce_update(bridge_t *br, param_cache_t *line)
{
    uv_update_time(br->loop);
    uint64_t now = uv_now(br->loop);
    double obs   = 1e-3*now;
    for(int i=0; i<br->debounce_len; ++i) {
        if(!strcmp(line->path, br->bounce[i].path)) {
            br->bounce[i].last_set = obs;
            return;
        }
    }
    debounce_push(br, line, obs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x2290
movq (%r15), %rdi
callq 0x2170
movq %rax, -0x38(%rbp)
movslq 0x124(%r15), %rax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %r13d
movq %rax, -0x30(%rbp)
cmovgl %eax, %r13d
shlq $0x4, %r13
addq $0x10, %r13
leaq 0x10(%rcx), %r14
cmpq %r14, %r13
je 0x3035
movq (%rbx), %rdi
movq 0x108(%r15), %r12
movq (%r12,%rcx), %rsi
callq 0x21a0
movq %r14, %rcx
testl %eax, %eax
jne 0x3008
leaq (%r12,%r14), %rax
addq $-0x8, %rax
jmp 0x3073
movq -0x30(%rbp), %rsi
incq %rsi
movl %esi, 0x124(%r15)
movq 0x108(%r15), %rdi
shlq $0x4, %rsi
callq 0x2240
movq %rax, 0x108(%r15)
movslq 0x124(%r15), %rcx
shlq $0x4, %rcx
movq (%rbx), %rdx
addq %rcx, %rax
addq $-0x8, %rax
movq %rdx, -0x8(%rax)
movsd -0x38(%rbp), %xmm0
unpcklps 0x4f91(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4f99(%rip), %xmm0     # 0x8020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x4f95(%rip), %xmm1     # 0x8030
movsd %xmm1, (%rax)
addq $0x18, %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/bridge.c
// Function: cache_get
static param_cache_t *cache_get(bridge_t *br, uri_t uri)
{
    for(int i=0; i<br->cache_len; ++i)
        if(!strcmp(br->cache[i].path, uri))
	    return br->cache + i;
    cache_push(br, uri);
    return cache_get(br, uri);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ecx, %ecx
pushq $-0x30
popq %rdx
movl 0x120(%r14), %eax
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x30, %rax, %r12
movq %rdx, %rcx
leaq 0x30(%rcx), %r13
cmpq %r13, %r12
je 0x3100
movq 0x100(%r14), %r15
movq 0x30(%r15,%rcx), %rdi
movq %rbx, %rsi
callq 0x21a0
movq %r13, %rcx
testl %eax, %eax
jne 0x30da
jmp 0x310d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3625
jmp 0x30c2
addq %r13, %r15
movq %r15, %rax
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/bridge.c
// Function: br_set_value_bool
void br_set_value_bool(bridge_t *br, uri_t uri, int value)
{
    rtosc_arg_t arg = {.i = value};
    char type = value ? 'T' : 'F';
    if(cache_set(br, uri, type, arg, 1)) {
        char buffer[1024];
        char typestr[2] = {type, '\0'};
        rtosc_message(buffer, 1024, uri, typestr, value);
        osc_send(br, buffer);
        debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %ecx
testl %edx, %edx
pushq $0x46
popq %rax
pushq $0x54
popq %r12
cmovel %eax, %r12d
pushq $0x1
popq %r9
movl %r12d, %edx
callq 0x31b4
testl %eax, %eax
je 0x31a4
leaq -0x22(%rbp), %rcx
movb %r12b, (%rcx)
movb $0x0, 0x1(%rcx)
leaq -0x430(%rbp), %r12
movl $0x400, %esi            # imm = 0x400
movq %r12, %rdi
movq %r14, %rdx
movl %r15d, %r8d
xorl %eax, %eax
callq 0x619b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x263e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2fbc
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_set
static int cache_set(bridge_t *br, uri_t uri, char type, rtosc_arg_t val, int skip_debounce)
{
    param_cache_t *line = cache_get(br, uri);
    assert(line);
    line->pending = false;
    if(!line->valid || line->type != type || memcmp(&line->val, &val, sizeof(val)))
    {
        if(line->type == 'v')
            declone_vec_value(line->vec_type, line->vec_value);
        else
            declone_value(line->type, line->val);
        line->valid = true;
        line->type  = type;
        line->val   = clone_value(type, val);
        line->requests = 0;

        //check if cache line is currently debounced...
        int debounced = false;
        for(int i=0; i<br->debounce_len; ++i)
            if(!strcmp(br->bounce[i].path, line->path))
                debounced = true;

        if(!debounced || skip_debounce)
            run_callbacks(br, line);

        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movq %r8, %r12
movq %rcx, %r13
movl %edx, %r14d
movq %rcx, -0x48(%rbp)
movq %r8, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
callq 0x30ae
testq %rax, %rax
je 0x32ec
movq %rax, %r15
movb 0x8(%rax), %cl
movb 0x9(%rax), %al
movl %ecx, %edx
andb $-0x3, %dl
movb %dl, 0x8(%r15)
cmpb %r14b, %al
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x322c
movdqu 0x20(%r15), %xmm0
movdqu -0x48(%rbp), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
movl %r14d, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x32d7
cmpb $0x62, %al
movl %ebx, -0x34(%rbp)
je 0x324a
movzbl %al, %eax
cmpl $0x76, %eax
jne 0x3253
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rsi
callq 0x2a8f
jmp 0x3253
movq 0x28(%r15), %rdi
callq 0x2030
orb $0x1, 0x8(%r15)
movb %r14b, 0x9(%r15)
movsbl %r14b, %edi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4074
movq %rax, 0x20(%r15)
movq %rdx, 0x28(%r15)
andl $0x0, 0x18(%r15)
movq -0x30(%rbp), %rax
movl 0x124(%rax), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
shlq $0x4, %r12
pushq $0x1
popq %r14
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x32bf
movq -0x30(%rbp), %rax
movq 0x108(%rax), %rax
movq (%rax,%r13), %rdi
movq (%r15), %rsi
callq 0x21a0
testl %eax, %eax
cmovel %r14d, %ebx
addq $0x10, %r13
jmp 0x3297
cmpl $0x0, -0x34(%rbp)
jne 0x32c9
testl %ebx, %ebx
jne 0x32da
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x3e0a
jmp 0x32da
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5007(%rip), %rdi      # 0x82fa
leaq 0x4e82(%rip), %rsi      # 0x817c
leaq 0x503d(%rip), %rcx      # 0x833e
pushq $0x77
popq %rdx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_has_callback
int br_has_callback(bridge_t *br, uri_t uri)
{
    for(int i=0; i < br->callback_len; ++i)
        if(!strcmp(br->callback[i].path, uri))
            return true;
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x128(%rdi), %rax
xorl %r12d, %r12d
testl %eax, %eax
movl $0x0, %r13d
movq %rax, -0x30(%rbp)
cmovgl %eax, %r13d
xorl %ecx, %ecx
movq %rcx, %r15
cmpq %rcx, %r13
je 0x33cc
movq 0x110(%r14), %rax
movq (%rax,%r12), %rdi
movq %rbx, %rsi
callq 0x21a0
leaq 0x1(%r15), %rcx
addq $0x18, %r12
testl %eax, %eax
jne 0x33a5
xorl %eax, %eax
cmpq -0x30(%rbp), %r15
setl %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/src/bridge.c
// Function: callback_push
static void callback_push(bridge_t *br, uri_t uri, bridge_cb_t cb, void *data)
{
    br->callback_len += 1;
    br->callback = (bridge_callback_t*)realloc(br->callback, br->callback_len*sizeof(bridge_callback_t));
    bridge_callback_t *ch = br->callback + (br->callback_len - 1);
    ch->path    = strdup(uri);
    ch->cb      = cb;
    ch->data    = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x128(%rdi), %rax
incq %rax
movl %eax, 0x128(%rdi)
movq 0x110(%rdi), %rdi
imulq $0x18, %rax, %rsi
callq 0x2240
movq %rax, %r13
movq %rax, 0x110(%r12)
movslq 0x128(%r12), %rax
imulq $0x18, %rax, %r12
movq %r15, %rdi
callq 0x22c0
movq %rax, -0x18(%r13,%r12)
movq %r14, -0x10(%r13,%r12)
movq %rbx, -0x8(%r13,%r12)
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/bridge.c
// Function: cache_push
static void cache_push(bridge_t *br, uri_t uri)
{
    if(!uri)
        return;
    assert(uri);
    br->cache_len += 1;
    br->cache = realloc(br->cache, br->cache_len*sizeof(param_cache_t));
    param_cache_t *ch = br->cache + (br->cache_len - 1);
    memset(ch, 0, sizeof(param_cache_t));
    ch->path    = strdup(uri);
    cache_update(br, ch);
}

// Assembly:
testq %rsi, %rsi
je 0x36a3
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x120(%rdi), %rax
incq %rax
movl %eax, 0x120(%rdi)
movq 0x100(%rdi), %rdi
imulq $0x30, %rax, %rsi
callq 0x2240
movq %rax, 0x100(%rbx)
movslq 0x120(%rbx), %rcx
imulq $0x30, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $-0x30, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
andq $0x0, 0x28(%r15)
movq %r14, %rdi
callq 0x22c0
movq %rax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36a4
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_update
static void cache_update(bridge_t *br, param_cache_t *ch)
{
    double now  = 1e-3*uv_now(br->loop);
    uri_t uri   = ch->path;
    ch->valid   = 0;
    ch->type    = 0;
    ch->usable  = 1;
    ch->pending = 1;
    ch->force_refresh = 0;
    ch->request_time = now;
    ch->requests++;
    memset(&ch->val, 0, sizeof(ch->val));

    if(osc_request_hook) {
        char buffer[128];
        const int len = rtosc_message(buffer, 128, uri, "");
        if(len <= 0)
            fprintf(stderr, "[ERROR] Osc Bridge Could Not Request Update For \"%s\"\n", uri);
    	osc_request_hook(br, buffer);
    } else
        osc_request(br, uri);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2170
movq %rax, %xmm0
punpckldq 0x4941(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4949(%rip), %xmm0     # 0x8020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x4945(%rip), %xmm1     # 0x8030
movq (%r15), %r14
movb 0x8(%r15), %al
movb $0x0, 0x9(%r15)
andb $-0x10, %al
orb $0x6, %al
movb %al, 0x8(%r15)
movsd %xmm1, 0x10(%r15)
incl 0x18(%r15)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%r15)
cmpq $0x0, 0x8af5(%rip)      # 0xc210
je 0x375c
leaq 0x4c88(%rip), %rcx      # 0x83ac
leaq -0xa0(%rbp), %rdi
movl $0x80, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x619b
testl %eax, %eax
jle 0x3774
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq *0x8ac2(%rip)           # 0xc210
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3931
movq 0x887d(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x4bf2(%rip), %rsi      # 0x8377
movq %r14, %rdx
xorl %eax, %eax
callq 0x21b0
jmp 0x373e
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_damage
void br_damage(bridge_t *br, uri_t dmg)
{
    //printf("Damage of parameters...\n");
    //printf("path is %s\n", dmg);
    for(int i=0; i<br->cache_len; ++i) {
        if(strstr(br->cache[i].path, dmg)) {
            int current = br_has_callback(br, br->cache[i].path);
            if(current) {
                osc_request(br, br->cache[i].path);
                br->cache[i].pending = true;
            } else
                br->cache[i].usable = false;
            br->cache[i].requests = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq 0x120(%r14), %rax
cmpq %rax, %r13
jge 0x3922
movq 0x100(%r14), %rbx
movq (%rbx,%r12), %r15
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x22d0
testq %rax, %rax
je 0x3919
movq %r14, %rdi
movq %r15, %rsi
callq 0x3375
testl %eax, %eax
je 0x3906
movq %r14, %rdi
movq %r15, %rsi
callq 0x3931
movq 0x100(%r14), %rax
orb $0x2, 0x8(%rax,%r12)
jmp 0x390c
andb $-0x5, 0x8(%rbx,%r12)
movq 0x100(%r14), %rax
andl $0x0, 0x18(%rax,%r12)
incq %r13
addq $0x30, %r12
jmp 0x38b5
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/bridge.c
// Function: br_refresh
void br_refresh(bridge_t *br, uri_t uri)
{
    param_cache_t *cline = cache_get(br, uri);

    uv_update_time(br->loop);
    double now = 1e-3*uv_now(br->loop);

    if(cline->request_time < now) {
        cline->request_time = now;
        osc_request(br, uri);
    } else {
        //printf("skipping refresh for %s at dt = %f\n", uri, cline->request_time-now);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x30ae
movq %rax, %r15
movq (%r14), %rdi
callq 0x2290
movq (%r14), %rdi
callq 0x2170
movq %rax, %xmm1
punpckldq 0x465d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x4665(%rip), %xmm1     # 0x8020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x4661(%rip), %xmm0     # 0x8030
ucomisd 0x10(%r15), %xmm0
jbe 0x39f2
movsd %xmm0, 0x10(%r15)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3931
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_force_refresh
void br_force_refresh(bridge_t *br, uri_t uri)
{
    param_cache_t *cline = cache_get(br, uri);

    uv_update_time(br->loop);
    double now = 1e-3*uv_now(br->loop);

    if(cline->request_time < now) {
        cline->request_time = now;
        osc_request(br, uri);
        cline->force_refresh = 0;
    } else {
        cline->request_time = now;
        cline->force_refresh = 1;
        //printf("skipping refresh for %s at dt = %f\n", uri, cline->request_time-now);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x30ae
movq %rax, %r15
movq (%r14), %rdi
callq 0x2290
movq (%r14), %rdi
callq 0x2170
movq %rax, %xmm0
punpckldq 0x45de(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x45e6(%rip), %xmm0     # 0x8020
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x45e2(%rip), %xmm1     # 0x8030
ucomisd 0x10(%r15), %xmm1
movsd %xmm1, 0x10(%r15)
jbe 0x3a6e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3931
andb $-0x9, 0x8(%r15)
jmp 0x3a73
orb $0x8, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_pending
int br_pending(bridge_t *br)
{
    int pending = 0;
    for(int i=0; i<br->cache_len; ++i)
        pending += !!(br->cache[i].pending);
    return pending;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x120(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
imulq $0x30, %rax, %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x3b5c
movq 0x100(%rdi), %rsi
btl $0x1, 0x8(%rsi,%rcx)
adcl $0x0, %eax
addq $0x30, %rcx
jmp 0x3b41
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: run_callbacks
static void
run_callbacks(bridge_t *br, param_cache_t *line)
{
    char buffer[1024*16];
    int len = 0;
    if(line->type != 'v') {
        char args[2] = {line->type, 0};
        assert(valid_type(line->type));
        len = rtosc_amessage(buffer, sizeof(buffer), line->path, args, &line->val);
    } else {
        len = rtosc_amessage(buffer, sizeof(buffer), line->path, line->vec_type,
                line->vec_value);
    }

    if(len == 0) {
        //TODO USE DYNAMIC ALLOCATION...
        printf("[ERROR] Message Too long for cache line <%s>\n", line->path);
        if(line->type != 'v') {
            char args[2] = {line->type, 0};
            assert(valid_type(line->type));
            len = rtosc_amessage(0, 0, line->path, args, &line->val);
        } else {
            len = rtosc_amessage(0, 0, line->path, line->vec_type,
                    line->vec_value);
        }
        printf("[ERROR] Needs %d bytes of space...\n", len);
    }


    //run callbacks
    for(int i=0; i<br->callback_len; ++i)
        if(!strcmp(br->callback[i].path, line->path))
            br->callback[i].cb(buffer, br->callback[i].data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4008, %rsp           # imm = 0x4008
movq %rsi, %rbx
movq %rdi, %r14
movzbl 0x9(%rsi), %eax
movabsq $0x708d70006109, %r15   # imm = 0x708D70006109
cmpl $0x76, %eax
jne 0x3e4b
movq (%rbx), %rdx
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %r8
leaq -0x4030(%rbp), %rdi
jmp 0x3e7a
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
addl $-0x46, %eax
cmpl $0x2e, %eax
ja 0x3f46
btq %rax, %r15
jae 0x3f46
movq (%rbx), %rdx
leaq 0x20(%rbx), %r8
leaq -0x4030(%rbp), %rdi
leaq -0x2a(%rbp), %rcx
movl $0x4000, %esi           # imm = 0x4000
callq 0x64d1
testl %eax, %eax
jne 0x3ef0
movq (%rbx), %rsi
leaq 0x4562(%rip), %rdi      # 0x83f4
xorl %eax, %eax
callq 0x20f0
movzbl 0x9(%rbx), %eax
cmpl $0x76, %eax
jne 0x3eaf
movq (%rbx), %rdx
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %r8
jmp 0x3ed7
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
addl $-0x46, %eax
cmpl $0x2e, %eax
ja 0x3f65
btq %rax, %r15
jae 0x3f65
movq (%rbx), %rdx
leaq 0x20(%rbx), %r8
leaq -0x2a(%rbp), %rcx
xorl %edi, %edi
xorl %esi, %esi
callq 0x64d1
leaq 0x432c(%rip), %rdi      # 0x8213
movl %eax, %esi
xorl %eax, %eax
callq 0x20f0
pushq $0x10
popq %r12
xorl %r13d, %r13d
movslq 0x128(%r14), %rax
cmpq %rax, %r13
jge 0x3f34
movq 0x110(%r14), %r15
movq -0x10(%r15,%r12), %rdi
movq (%rbx), %rsi
callq 0x21a0
testl %eax, %eax
jne 0x3f2b
movq (%r15,%r12), %rsi
leaq -0x4030(%rbp), %rdi
callq *-0x8(%r15,%r12)
incq %r13
addq $0x18, %r12
jmp 0x3ef7
addq $0x4008, %rsp           # imm = 0x4008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4460(%rip), %rdi      # 0x83ad
leaq 0x4228(%rip), %rsi      # 0x817c
leaq 0x4469(%rip), %rcx      # 0x83c4
movl $0x23d, %edx            # imm = 0x23D
callq 0x2130
leaq 0x4441(%rip), %rdi      # 0x83ad
leaq 0x4209(%rip), %rsi      # 0x817c
leaq 0x444a(%rip), %rcx      # 0x83c4
movl $0x249, %edx            # imm = 0x249
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: print_stats
void print_stats(bridge_t *br, schema_t sch)
{
    printf("Bridge Statistics:\n");
    printf("    Total cache lines:          %d\n", br->cache_len);
    printf("    Total callbacks:            %d\n", br->callback_len);
    printf("Schema Statistics:\n");
    printf("    Known Parameters Patterns:  %d\n", sch.elements);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x44fb(%rip), %rdi      # 0x84fc
callq 0x2080
movl 0x120(%rbx), %esi
leaq 0x427b(%rip), %rdi      # 0x828e
xorl %eax, %eax
callq 0x20f0
movl 0x128(%rbx), %esi
leaq 0x428b(%rip), %rdi      # 0x82b2
xorl %eax, %eax
callq 0x20f0
leaq 0x44da(%rip), %rdi      # 0x850f
callq 0x2080
movl 0x20(%rbp), %esi
leaq 0x4292(%rip), %rdi      # 0x82d6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/bridge.c
// Function: clone_value
static rtosc_arg_t
clone_value(char type, rtosc_arg_t val)
{
    if(type == 'b') {
        char *data = (char*)val.b.data;
        val.b.data = malloc(val.b.len);
        memcpy(val.b.data, data, val.b.len);
    } else if(type == 's') {
        val.s = strdup(val.s);
    }
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpl $0x73, %edi
je 0x40b0
cmpl $0x62, %edi
jne 0x40bb
movslq %r14d, %r15
movq %r15, %rdi
callq 0x2200
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21e0
movq %r12, %rbx
jmp 0x40bb
movq %r14, %rdi
callq 0x22c0
movq %rax, %r14
movq %r14, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_stoi
static mm_json_number
mm_json_stoi(struct mm_json_token *tok)
{
    mm_json_number n = 0;
    mm_json_size i = 0;
    mm_json_size off;
    mm_json_size neg;
    if (!tok->str || !tok->len)
        return 0;

    off = (tok->str[0] == '-' || tok->str[0] == '+') ? 1 : 0;
    neg = (tok->str[0] == '-') ? 1 : 0;
    for (i = off; i < tok->len; i++) {
        if ((tok->str[i] >= '0') && (tok->str[i] <= '9'))
            n = (n * 10) + tok->str[i]  - '0';
    }
    return (neg) ? -n : n;
}

// Assembly:
movq (%rdi), %rax
xorpd %xmm0, %xmm0
testq %rax, %rax
je 0x458e
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x458e
pushq %rbp
movq %rsp, %rbp
movb (%rax), %dl
leal -0x2b(%rdx), %edi
xorl %esi, %esi
testb $-0x3, %dil
sete %sil
xorpd %xmm0, %xmm0
movsd 0x3ff4(%rip), %xmm1     # 0x8538
movsd 0x3ff4(%rip), %xmm2     # 0x8540
cmpq %rsi, %rcx
je 0x4580
movsbl (%rax,%rsi), %edi
leal -0x30(%rdi), %r8d
cvtsi2sd %edi, %xmm4
movapd %xmm0, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm4, %xmm3
addsd %xmm2, %xmm3
cmpb $0xa, %r8b
jb 0x4577
movapd %xmm0, %xmm3
incq %rsi
movapd %xmm3, %xmm0
jmp 0x454c
cmpb $0x2d, %dl
jne 0x458d
xorpd 0x3fc3(%rip), %xmm0     # 0x8550
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_cpy
MM_JSON_API mm_json_size
mm_json_cpy(mm_json_char *dst, mm_json_size max, const struct mm_json_token* tok)
{
    unsigned i = 0;
    mm_json_size ret;
    mm_json_size siz;

    MM_JSON_ASSERT(dst);
    MM_JSON_ASSERT(tok);
    if (!dst || !max || !tok)
        return 0;

    ret = (max < (tok->len + 1)) ? max : tok->len;
    siz = (max < (tok->len + 1)) ? max-1 : tok->len;
    for (i = 0; i < siz; i++)
        dst[i] = tok->str[i];
    dst[siz] = '\0';
    return ret;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %r8b
xorl %eax, %eax
orb %cl, %r8b
jne 0x45e8
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdx), %rcx
leaq 0x1(%rcx), %r9
leaq -0x1(%rsi), %r8
cmpq %rsi, %r9
cmovbeq %rcx, %r8
movl %eax, %eax
cmpq %rax, %r8
jbe 0x45d8
movq (%rdx), %r10
movb (%r10,%rax), %r10b
movb %r10b, (%rdi,%rax)
incl %eax
jmp 0x45c2
cmpq %rsi, %r9
cmovaq %rsi, %rcx
movb $0x0, (%rdi,%r8)
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_cmp
MM_JSON_API mm_json_int
mm_json_cmp(const struct mm_json_token* tok, const mm_json_char* str)
{
    mm_json_size i;
    MM_JSON_ASSERT(tok);
    MM_JSON_ASSERT(str);
    if (!tok || !str) return 1;
    for (i = 0; (i < tok->len && *str); i++, str++){
        if (tok->str[i] != *str)
            return 1;
    }
    return 0;
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0x1, %eax
orb %cl, %dl
jne 0x4627
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x4624
movb (%rsi,%rdx), %r8b
testb %r8b, %r8b
je 0x4624
movq (%rdi), %r9
cmpb %r8b, (%r9,%rdx)
jne 0x4626
incq %rdx
jmp 0x4608
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_begin
MM_JSON_API struct mm_json_iter
mm_json_begin(const mm_json_char *str, mm_json_size len)
{
    struct mm_json_iter iter = MM_JSON_ITER_NULL;
    mm_json_init();
    iter.src = str;
    iter.len = len;
    return iter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x40cc
movq %r14, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %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/src/mm_json.h
// Function: mm_json_type
static enum mm_json_token_type
mm_json_type(const struct mm_json_token *tok)
{
    if (!tok || !tok->str || !tok->len)
        return MM_JSON_NONE;
    if (tok->str[0] == '{')
        return MM_JSON_OBJECT;
    if (tok->str[0] == '[')
        return MM_JSON_ARRAY;
    if (tok->str[0] == '\"')
        return MM_JSON_STRING;
    if (tok->str[0] == 't')
        return MM_JSON_TRUE;
    if (tok->str[0] == 'f')
        return MM_JSON_FALSE;
    if (tok->str[0] == 'n')
        return MM_JSON_NULL;
    return MM_JSON_NUMBER;
}

// Assembly:
movq (%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x4a4e
cmpq $0x0, 0x8(%rdi)
je 0x4a4e
pushq %rbp
movq %rsp, %rbp
movzbl (%rcx), %eax
cmpl $0x22, %eax
je 0x4a48
cmpl $0x7b, %eax
je 0x4a41
cmpl $0x66, %eax
je 0x4a25
cmpl $0x6e, %eax
je 0x4a33
cmpl $0x74, %eax
je 0x4a2c
cmpl $0x5b, %eax
jne 0x4a3a
movl $0x2, %eax
jmp 0x4a4d
movl $0x6, %eax
jmp 0x4a4d
movl $0x5, %eax
jmp 0x4a4d
movl $0x7, %eax
jmp 0x4a4d
movl $0x3, %eax
jmp 0x4a4d
movl $0x1, %eax
jmp 0x4a4d
movl $0x4, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_parse
MM_JSON_API struct mm_json_iter
mm_json_parse(struct mm_json_pair *p, const struct mm_json_iter* it)
{
    struct mm_json_iter next;
    MM_JSON_ASSERT(p);
    MM_JSON_ASSERT(it);
    next = mm_json_read(&p->name, it);
    if (next.err) return next;
    return mm_json_read(&p->value, &next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x465c
cmpl $0x0, (%r15)
je 0x4a9e
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x4ab1
addq $0x28, %r14
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x465c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
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_num
MM_JSON_API mm_json_size
mm_json_num(const mm_json_char *json, mm_json_size length)
{
    struct mm_json_iter iter;
    struct mm_json_token tok;
    mm_json_size count = 0;

    MM_JSON_ASSERT(json);
    MM_JSON_ASSERT(length);
    if (!json || !length)
        return 0;

    iter = mm_json_begin(json, length);
    iter = mm_json_read(&tok, &iter);
    while (!iter.err) {
        count += (1 + tok.sub);
        iter = mm_json_read(&tok, &iter);
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x4b57
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rbx
movaps %xmm0, (%rbx)
callq 0x40cc
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
leaq -0x60(%rbp), %r14
leaq -0x88(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x465c
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%rbx)
movaps %xmm0, (%rbx)
xorl %r12d, %r12d
cmpl $0x0, -0x40(%rbp)
jne 0x4b5a
movq -0x70(%rbp), %rax
addq %rax, %r12
incq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x465c
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
jmp 0x4b27
xorl %r12d, %r12d
movq %r12, %rax
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_path_parse_name
static const mm_json_char*
mm_json_path_parse_name(struct mm_json_token *tok, const mm_json_char *path,
    mm_json_char delimiter)
{
    const mm_json_char *del;
    const mm_json_char *begin, *end;
    if (!path || *path == '\0')
        return NULL;

    tok->str = path;
    del = mm_json_strchr(tok->str, delimiter, -1);
    begin = mm_json_strchr(tok->str, '[', -1);
    end = mm_json_strchr(tok->str, ']', -1);

    /* array part left */
    if (begin && end && begin == tok->str) {
        tok->len = (mm_json_size)((end - begin) + 1);
        if (*(end + 1) == '\0')
            return NULL;
        if (*(end + 1) == '.')
            return(end + 2);
        else return(end + 1);
    }

    /* only array after name */
    if (begin < del) {
        tok->len = (mm_json_size)(begin - tok->str);
        return begin;
    }

    if (!del) return NULL;
    if (*del == '\0') {
        tok->len = (mm_json_size)(del - tok->str);
        return NULL;
    }
    tok->len = (mm_json_size)(del - tok->str);
    return del+1;
}

// Assembly:
cmpb $0x0, (%rsi)
je 0x5120
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
movsbl %dl, %esi
pushq $-0x1
popq %r13
movq %r14, %rdi
movl %r13d, %edx
callq 0x5d16
movq %rax, %r15
pushq $0x5b
popq %rsi
movq %r14, %rdi
movl %r13d, %edx
callq 0x5d16
movq %rax, %r12
pushq $0x5d
popq %rsi
movq %r14, %rdi
movl %r13d, %edx
callq 0x5d16
testq %rax, %rax
sete %dl
movq %r12, %rcx
subq %r14, %rcx
setne %sil
orb %dl, %sil
jne 0x5123
movq %rax, %rcx
subq %r14, %rcx
incq %rcx
movq %rcx, 0x8(%rbx)
movzbl 0x1(%rax), %ecx
testl %ecx, %ecx
je 0x5152
cmpl $0x2e, %ecx
jne 0x5156
addq $0x2, %rax
jmp 0x5159
xorl %eax, %eax
retq
cmpq %r15, %r12
jae 0x5131
movq %rcx, 0x8(%rbx)
movq %r12, %rax
jmp 0x5159
testq %r15, %r15
je 0x5152
movq %r15, %rcx
subq %r14, %rcx
movq %r15, %rdx
incq %rdx
xorl %eax, %eax
cmpb $0x0, (%r15)
movq %rcx, 0x8(%rbx)
cmovneq %rdx, %rax
jmp 0x5159
xorl %eax, %eax
jmp 0x5159
incq %rax
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_number_del
MM_JSON_API mm_json_int
mm_json_query_number_del(mm_json_number *num, 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(num);
    MM_JSON_ASSERT(path);
    if (!toks || !count || !num || !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_NUMBER)
        return tok->type;
    return mm_json_convert(num, tok);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testq %rcx, %rcx
je 0x51c7
movq %rdi, %r14
testq %rdi, %rdi
je 0x51c7
testq %rsi, %rsi
je 0x51c7
testq %rdx, %rdx
je 0x51c7
movsbl %r8b, %eax
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movl %eax, %ecx
callq 0x4cfe
testq %rax, %rax
je 0x51c7
movl 0x20(%rax), %ebx
cmpl $0x3, %ebx
jne 0x51c7
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x42c1
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq