LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %edx
movl $0x46, %eax
movl $0x54, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x29(%rbp), %al
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x1, %r9d
movsbl %al, %edx
callq 0x36f0
cmpl $0x0, %eax
je 0x36e1
movb -0x29(%rbp), %al
movb %al, -0x432(%rbp)
movb $0x0, -0x431(%rbp)
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x432(%rbp), %rcx
movl -0x14(%rbp), %r8d
movl $0x400, %esi            # imm = 0x400
movb $0x0, %al
callq 0x8900
movq -0x8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x26d0
movq -0x8(%rbp), %rax
movq %rax, -0x440(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3580
movq -0x440(%rbp), %rdi
movq %rax, %rsi
callq 0x3490
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: br_set_value_string
void br_set_value_string(bridge_t *br, uri_t uri, const char *str)
{
    rtosc_arg_t arg = {.s = str};
    if(cache_set(br, uri, 's', arg, 1)) {
        char buffer[1024];
        rtosc_message(buffer, 1024, uri, "s", str);
        osc_send(br, buffer);
        //debounce_update(br, cache_get(br, uri));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x73, %edx
movl $0x1, %r9d
callq 0x36f0
cmpl $0x0, %eax
je 0x3956
leaq -0x430(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x881b(%rip), %rcx      # 0xc15a
movb $0x0, %al
callq 0x8900
movq -0x8(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x26d0
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x128(%rcx), %eax
jge 0x39c3
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x39b6
movl $0x1, -0x4(%rbp)
jmp 0x39ca
jmp 0x39b8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3977
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x128(%rax)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x128(%rax), %rax
imulq $0x18, %rax, %rsi
callq 0x2230
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x128(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: cache_has
static int cache_has(param_cache_t *c, size_t len, uri_t uri)
{
    for(size_t i=0; i<len; ++i)
        if(!strcmp(c[i].path, uri))
            return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3d4c
movq -0x10(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x3d3c
movl $0x1, -0x4(%rbp)
jmp 0x3d53
jmp 0x3d3e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3d0c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d7c
jmp 0x3e3a
cmpq $0x0, -0x10(%rbp)
je 0x3d85
jmp 0x3da4
leaq 0x870a(%rip), %rdi      # 0xc496
leaq 0x847c(%rip), %rsi      # 0xc20f
movl $0x36, %edx
leaq 0x86fb(%rip), %rcx      # 0xc49a
callq 0x2120
movq -0x8(%rbp), %rax
movl 0x120(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x120(%rax)
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x120(%rax), %rax
imulq $0x30, %rax, %rsi
callq 0x2230
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x120(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2130
movq -0x10(%rbp), %rdi
callq 0x22a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e40
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq %rax, %xmm1
movaps 0x81a5(%rip), %xmm0     # 0xc010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x81a9(%rip), %xmm0     # 0xc020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x81a2(%rip), %xmm0     # 0xc030
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x9(%rax)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
movb 0x8(%rax), %cl
andb $-0x9, %cl
orb $0x0, %cl
movb %cl, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2130
cmpq $0x0, 0xc2df(%rip)      # 0x10200
je 0x3f82
leaq -0xa0(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x80, %esi
leaq 0x85b8(%rip), %rcx      # 0xc4f2
movb $0x0, %al
callq 0x8900
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jg 0x3f6c
movq 0xc0a1(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x8558(%rip), %rsi      # 0xc4bd
movb $0x0, %al
callq 0x21b0
movq 0xc28d(%rip), %rax      # 0x10200
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq *%rax
jmp 0x3f8f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4320
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: valid_type
static int valid_type(char ch)
{
    switch(ch)
    {
        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':
        case 'T':
        case 'F':
        case 'N':
        case 'I':
            return 1;
        default:
            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 0x4014
jmp 0x3fb8
movl -0xc(%rbp), %eax
subl $0x49, %eax
je 0x4014
jmp 0x3fc2
movl -0xc(%rbp), %eax
subl $0x4e, %eax
je 0x4014
jmp 0x3fcc
movl -0xc(%rbp), %eax
addl $-0x53, %eax
subl $0x2, %eax
jb 0x4014
jmp 0x3fd9
movl -0xc(%rbp), %eax
addl $-0x62, %eax
subl $0x3, %eax
jb 0x4014
jmp 0x3fe6
movl -0xc(%rbp), %eax
subl $0x66, %eax
je 0x4014
jmp 0x3ff0
movl -0xc(%rbp), %eax
addl $-0x68, %eax
subl $0x2, %eax
jb 0x4014
jmp 0x3ffd
movl -0xc(%rbp), %eax
subl $0x6d, %eax
je 0x4014
jmp 0x4007
movl -0xc(%rbp), %eax
addl $-0x72, %eax
subl $0x2, %eax
ja 0x401d
jmp 0x4014
movl $0x1, -0x4(%rbp)
jmp 0x4024
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: callback_pop
static void callback_pop(bridge_t *br, uri_t uri, bridge_cb_t cb, void *data)
{
    int len = br->callback_len;

    int idx = 0;
    while(idx < len) {
        bridge_callback_t item = br->callback[idx];
        if(!strcmp(item.path, uri) && item.cb == cb && item.data == data) {
            //We should remove this element

            //Deallocate resources
            free((void*)item.path);

            //Move all other items
            for(int i=idx; i<len-1; ++i)
                br->callback[i] = br->callback[i+1];

            //Shrink list
            len--;
        } else {
            //move on to the next element of the list
            idx++;
        }
    }

    br->callback_len = len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x41ea
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x41dc
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x41dc
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x41dc
movq -0x40(%rbp), %rdi
callq 0x2030
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x41d1
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movslq -0x44(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x110(%rcx), %rcx
movl -0x44(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4172
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41e5
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x40fc
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x128(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jge 0x4316
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x22b0
cmpq $0x0, %rax
je 0x4306
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x3960
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x42c7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x4320
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x8(%rax), %cl
andb $-0x3, %cl
orb $0x2, %cl
movb %cl, 0x8(%rax)
jmp 0x42e9
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x8(%rax), %cl
andb $-0x5, %cl
orb $0x0, %cl
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x18(%rax)
jmp 0x4308
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4217
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3580
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2280
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq %rax, %xmm1
movaps 0x7c4b(%rip), %xmm0     # 0xc010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x7c4f(%rip), %xmm0     # 0xc020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x7c48(%rip), %xmm0     # 0xc030
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4422
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4320
jmp 0x4424
jmp 0x4424
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3580
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2280
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2170
movq %rax, %xmm1
movaps 0x7b9b(%rip), %xmm0     # 0xc010
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x7b9f(%rip), %xmm0     # 0xc020
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x7b98(%rip), %xmm0     # 0xc030
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x20(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44e2
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4320
movq -0x18(%rbp), %rax
movb 0x8(%rax), %cl
andb $-0x9, %cl
orb $0x0, %cl
movb %cl, 0x8(%rax)
jmp 0x4500
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %cl
andb $-0x9, %cl
orb $0x8, %cl
movb %cl, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jge 0x4633
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb 0x8(%rax), %al
shlb $0x6, %al
sarb $0x7, %al
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45e6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: debounce_pop
static void debounce_pop(bridge_t *br, int idx)
{
    assert(idx < br->debounce_len);
    for(int i=idx; i<br->debounce_len-1; ++i)
        br->bounce[i] = br->bounce[i+1];
    br->debounce_len -= 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x124(%rcx), %eax
jge 0x4d50
jmp 0x4d6f
leaq 0x7811(%rip), %rdi      # 0xc568
leaq 0x74b1(%rip), %rsi      # 0xc20f
movl $0x1ee, %edx            # imm = 0x1EE
leaq 0x7815(%rip), %rcx      # 0xc57f
callq 0x2120
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x124(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4dd3
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x108(%rcx), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d75
movq -0x8(%rbp), %rax
movl 0x124(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x124(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x74ea(%rip), %rdi      # 0xc385
movb $0x0, %al
callq 0x20e0
movq -0x8(%rbp), %rax
movl 0x120(%rax), %esi
leaq 0x74e6(%rip), %rdi      # 0xc399
movb $0x0, %al
callq 0x20e0
movq -0x8(%rbp), %rax
movl 0x128(%rax), %esi
leaq 0x74f2(%rip), %rdi      # 0xc3bd
movb $0x0, %al
callq 0x20e0
leaq 0x7508(%rip), %rdi      # 0xc3e1
movb $0x0, %al
callq 0x20e0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq 0x7507(%rip), %rdi      # 0xc3f5
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: clone_vec_value
static rtosc_arg_t *
clone_vec_value(char *type, rtosc_arg_t *val)
{
    int n = strlen(type);
    rtosc_arg_t *nargs = calloc(sizeof(rtosc_arg_t), n);
    for(int i=0; i<n; ++i) {
        nargs[i] = clone_value(type[i], val[i]);
    }
    return nargs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rsi
movl $0x10, %edi
callq 0x2180
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4fe2
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movsbl %al, %edi
callq 0x4ff0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f75
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %dil, %al
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x62, %eax
jne 0x5037
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x20(%rbp), %rdi
callq 0x2200
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x21e0
jmp 0x504f
movsbl -0x21(%rbp), %eax
cmpl $0x73, %eax
jne 0x504d
movq -0x20(%rbp), %rdi
callq 0x22a0
movq %rax, -0x20(%rbp)
jmp 0x504f
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/bridge.c
// Function: debounce_push
static void debounce_push(bridge_t *br, param_cache_t *line, double obs)
{
    br->debounce_len += 1;
    br->bounce        = (debounce_t*)realloc(br->bounce, br->debounce_len*sizeof(debounce_t));
    debounce_t *bo = br->bounce + (br->debounce_len - 1);
    bo->path = line->path;
    bo->last_set = obs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x124(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x124(%rax)
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x124(%rax), %rsi
shlq $0x4, %rsi
callq 0x2230
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x8(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x124(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x572d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x573a
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5859
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x31(%rbp)
je 0x5761
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x2d, %edx
cmovel %ecx, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x581b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x580b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x580b
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cvtsi2sd %eax, %xmm1
movsd 0x6dc6(%rip), %xmm2     # 0xc5b8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x6dae(%rip), %xmm1     # 0xc5b0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x580d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x579c
cmpq $0x0, -0x30(%rbp)
je 0x5845
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x584f
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_stof
static mm_json_number
mm_json_stof(struct mm_json_token *tok)
{
    mm_json_size i = 0;
    mm_json_number n = 0;
    mm_json_number f = 0.1;
    if (!tok->str || !tok->len) return 0;
    for (i = 0; i < tok->len; i++) {
        if ((tok->str[i] >= '0') && (tok->str[i] <= '9')) {
            n = n + (tok->str[i] - '0') * f;
            f *= 0.1;
        }
    }
    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x6d40(%rip), %xmm0     # 0xc5c0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x589a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x58a7
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x5941
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x5937
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x5924
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x5924
movsd -0x20(%rbp), %xmm1
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x6ca6(%rip), %xmm0     # 0xc5c0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x5926
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x58af
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
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_ipow
static mm_json_number
mm_json_ipow(int base, unsigned exp)
{
    long res = 1;
    while (exp) {
        if (exp & 1)
            res *= base;
        exp >>= 1;
        base *= base;
    }
    return (mm_json_number)res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x5994
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5980
movslq -0x4(%rbp), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
imull -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5962
cvtsi2sdq -0x10(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59cc
cmpq $0x0, -0x18(%rbp)
je 0x59cc
cmpq $0x0, -0x20(%rbp)
jne 0x59d9
movq $0x0, -0x8(%rbp)
jmp 0x5a89
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x59f8
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x5a04
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x5a2f
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x5a3b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x38(%rbp), %rax
jae 0x5a75
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5a4a
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5aaa
cmpq $0x0, -0x18(%rbp)
jne 0x5ab3
movl $0x1, -0x4(%rbp)
jmp 0x5b2d
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x21(%rbp)
jae 0x5ade
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5ae7
jmp 0x5b26
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x5b0a
movl $0x1, -0x4(%rbp)
jmp 0x5b2d
jmp 0x5b0c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5abb
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/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
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x2130
callq 0x5110
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6114
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6114
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x6120
movl $0x0, -0x4(%rbp)
jmp 0x61b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x6138
movl $0x1, -0x4(%rbp)
jmp 0x61b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x6150
movl $0x2, -0x4(%rbp)
jmp 0x61b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x6168
movl $0x4, -0x4(%rbp)
jmp 0x61b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x6180
movl $0x5, -0x4(%rbp)
jmp 0x61b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jne 0x6198
movl $0x6, -0x4(%rbp)
jmp 0x61b7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x61b0
movl $0x7, -0x4(%rbp)
jmp 0x61b7
movl $0x3, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x5b90
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x6274
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x6289
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq -0x30(%rbp), %rdx
callq 0x5b90
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x68(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x62c9
cmpq $0x0, -0x18(%rbp)
jne 0x62d6
movq $0x0, -0x8(%rbp)
jmp 0x63b6
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x5b40
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5b90
movq -0xa8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x38(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x635c
jmp 0x63ae
movq -0x48(%rbp), %rax
addq $0x1, %rax
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x5b90
movq -0xc8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x634d
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_path_parse_array
static mm_json_int
mm_json_path_parse_array(struct mm_json_token *array, const struct mm_json_token *token)
{
    const mm_json_char *begin;
    const mm_json_char *end;

    array->str = token->str;
    begin = mm_json_strchr(array->str, '[', (mm_json_int)token->len);
    if (!begin || ((mm_json_size)(begin - array->str) >= token->len))
        return 0;

    end = mm_json_strchr(begin, ']', (mm_json_int)(token->len - (mm_json_size)(begin - array->str)));
    if (!end || ((mm_json_size)(end - array->str) >= token->len))
        return 0;

    array->str = begin + 1;
    array->len = (mm_json_size)((end-1) - begin);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
movl $0x5b, %esi
callq 0x7fe0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6cdc
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x6ce8
movl $0x0, -0x4(%rbp)
jmp 0x6d6a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movl %eax, %edx
movl $0x5d, %esi
callq 0x7fe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6d34
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x6d3d
movl $0x0, -0x4(%rbp)
jmp 0x6d6a
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $-0x1, %rcx
movq -0x20(%rbp), %rax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_lcmp
static mm_json_int
mm_json_lcmp(const struct mm_json_token* tok, const mm_json_char* str, mm_json_size len)
{
    mm_json_size i;
    MM_JSON_ASSERT(tok);
    MM_JSON_ASSERT(str);
    if (!tok || !str || !len) return 1;
    for (i = 0; (i < tok->len && i < len); i++, str++){
        if (tok->str[i] != *str)
            return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6da5
cmpq $0x0, -0x18(%rbp)
je 0x6da5
cmpq $0x0, -0x20(%rbp)
jne 0x6dae
movl $0x1, -0x4(%rbp)
jmp 0x6e26
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x29(%rbp)
jae 0x6dd7
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x6de0
jmp 0x6e1f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x6e03
movl $0x1, -0x4(%rbp)
jmp 0x6e26
jmp 0x6e05
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6db6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_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
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e9a
cmpq $0x0, -0x20(%rbp)
je 0x6e9a
cmpq $0x0, -0x10(%rbp)
je 0x6e9a
cmpq $0x0, -0x28(%rbp)
jne 0x6ea3
movl $0x0, -0x4(%rbp)
jmp 0x6ef2
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movsbl -0x29(%rbp), %ecx
callq 0x6630
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6ecc
movl $0x0, -0x4(%rbp)
jmp 0x6ef2
movq -0x38(%rbp), %rax
cmpl $0x3, 0x20(%rax)
je 0x6ee2
movq -0x38(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ef2
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x53a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %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_query_string_del
MM_JSON_API mm_json_int
mm_json_query_string_del(mm_json_char *buffer, mm_json_size max, mm_json_size *size,
    struct mm_json_token *toks, mm_json_size count, const mm_json_char *path, mm_json_char del)
{
    struct mm_json_token *tok;
    MM_JSON_ASSERT(toks);
    MM_JSON_ASSERT(count);
    MM_JSON_ASSERT(buffer);
    MM_JSON_ASSERT(size);
    MM_JSON_ASSERT(path);
    if (!toks || !count || !buffer || !size || !path)
        return MM_JSON_NONE;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb 0x10(%rbp), %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6f86
cmpq $0x0, -0x30(%rbp)
je 0x6f86
cmpq $0x0, -0x10(%rbp)
je 0x6f86
cmpq $0x0, -0x20(%rbp)
je 0x6f86
cmpq $0x0, -0x38(%rbp)
jne 0x6f8f
movl $0x0, -0x4(%rbp)
jmp 0x6ff3
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movsbl 0x10(%rbp), %ecx
callq 0x6630
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6fb8
movl $0x0, -0x4(%rbp)
jmp 0x6ff3
movq -0x40(%rbp), %rax
cmpl $0x4, 0x20(%rax)
je 0x6fce
movq -0x40(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x6ff3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x59a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/mm_json.h
// Function: mm_json_query_type_del
MM_JSON_API mm_json_int
mm_json_query_type_del(struct mm_json_token *toks, mm_json_size count, const mm_json_char *path,
    mm_json_char del)
{
    struct mm_json_token *tok;
    MM_JSON_ASSERT(toks);
    MM_JSON_ASSERT(count);
    MM_JSON_ASSERT(path);
    if (!toks || !count || !path)
        return MM_JSON_NONE;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x707e
cmpq $0x0, -0x18(%rbp)
je 0x707e
cmpq $0x0, -0x20(%rbp)
jne 0x7087
movl $0x0, -0x4(%rbp)
jmp 0x70ba
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movsbl -0x21(%rbp), %ecx
callq 0x6630
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x70b0
movl $0x0, -0x4(%rbp)
jmp 0x70ba
movq -0x30(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/src/parse-schema.c
// Function: strndup_custom
static char *strndup_custom(const char *data, int len)
{
    char *dest = calloc(len+1,1);
    for(int i=0; i<len; ++i)
        dest[i] = data[i];
    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x74d6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x74ad
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq