LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/../htslib/kstring.h
// Function: kinsert_str
static inline int kinsert_str(const char *str, size_t pos, kstring_t *s)
{
    size_t len = 0;
    if (!s || pos > s->l || !str)  {
        return EOF;
    }
    if (!(len = strlen(str))) {
        return 0;
    }
    if (ks_resize(s, s->l + len + 1) < 0) {
        return EOF;
    }
    memmove(s->s + pos + len, s->s + pos, s->l - pos);
    memcpy(s->s + pos, str, len);
    s->l += len;
    s->s[s->l] = '\0';
    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)
cmpq $0x0, -0x20(%rbp)
je 0x3947
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
ja 0x3947
cmpq $0x0, -0x10(%rbp)
jne 0x3953
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a05
movq -0x10(%rbp), %rdi
callq 0x1090
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3972
movl $0x0, -0x4(%rbp)
jmp 0x3a05
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
addq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x2f90
cmpl $0x0, %eax
jge 0x3998
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a05
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
addq -0x18(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
subq -0x18(%rbp), %rdx
callq 0x1190
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
addq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x10e0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/lib/ae/ae.c
// Function: aeMain
void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        if (eventLoop->beforesleep != NULL)
            eventLoop->beforesleep(eventLoop);
        aeProcessEvents(eventLoop, AE_ALL_EVENTS|AE_CALL_AFTER_SLEEP);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x36aa
jmp 0x36d3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x36c3
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
movl $0xb, %esi
callq 0x2ea0
jmp 0x3697
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/lib/utf8_decode.c
// Function: utf8_decode_init
void utf8_decode_init(char p[], int length) {
    the_index = 0;
    the_input = p;
    the_length = length;
    the_char = 0;
    the_byte = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, 0x11ae3(%rip)     # 0x15238
movq -0x8(%rbp), %rax
movq %rax, 0x11ae0(%rip)     # 0x15240
movl -0xc(%rbp), %eax
movl %eax, 0x11adf(%rip)     # 0x15248
movl $0x0, 0x11ad9(%rip)     # 0x1524c
movl $0x0, 0x11ad3(%rip)     # 0x15250
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/lib/utf8_decode.c
// Function: get
static int get() {
    int c;
    if (the_index >= the_length) {
        return UTF8_END;
    }
    c = the_input[the_index] & 0xFF;
    the_index += 1;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x118be(%rip), %eax     # 0x15238
cmpl 0x118c8(%rip), %eax     # 0x15248
jl 0x398b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x39ba
movq 0x118ae(%rip), %rax     # 0x15240
movslq 0x1189f(%rip), %rcx     # 0x15238
movsbl (%rax,%rcx), %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
movl 0x1188d(%rip), %eax     # 0x15238
addl $0x1, %eax
movl %eax, 0x11884(%rip)     # 0x15238
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/lib/utf8_decode.c
// Function: cont
static int cont() {
    int c = get();
    return ((c & 0xC0) == 0x80)
        ? (c & 0x3F)
        : UTF8_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x3970
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
jne 0x39ea
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x8(%rbp)
jmp 0x39f4
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl %eax, -0x8(%rbp)
jmp 0x39f4
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/lib/cJSON.c
// Function: cJSON_AddItemToObject
CJSON_PUBLIC(void) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item)
{
    if (item == NULL)
    {
        return;
    }

    /* call cJSON_AddItemToObjectCS for code reuse */
    cJSON_AddItemToObjectCS(object, (char*)cJSON_strdup((const unsigned char*)string, &global_hooks), item);
    /* remove cJSON_StringIsConst flag */
    item->type &= ~cJSON_StringIsConst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b6d
jmp 0x4ba5
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x10688(%rip), %rsi     # 0x15208
callq 0x4c30
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x4bb0
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
movl %ecx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/lib/cJSON.c
// Function: cJSON_AddItemToObjectCS
CJSON_PUBLIC(void) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item)
{
    if ((item == NULL) || (string == NULL))
    {
        return;
    }
    if (!(item->type & cJSON_StringIsConst) && item->string)
    {
        global_hooks.deallocate(item->string);
    }
    item->string = (char*)string;
    item->type |= cJSON_StringIsConst;
    cJSON_AddItemToArray(object, item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4bd2
cmpq $0x0, -0x10(%rbp)
jne 0x4bd4
jmp 0x4c2a
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x4c01
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x4c01
movq 0x10619(%rip), %rax     # 0x15210
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4aa0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_create_ex
struct buffer *buf_create_ex(size_t size, size_t prepend_size)
{
    assert(size > 0);
    assert(prepend_size >= 0);

    size_t sz = size + prepend_size;
    struct buffer *buf = calloc(1, sizeof(*buf));
    if (buf == NULL)
    {
        return NULL;
    }
    buf->buf = calloc(1, sz);
    if (buf->buf == NULL)
    {
        free(buf);
        return NULL;
    }
    buf->sz = sz;
    buf->read_idx = prepend_size;
    buf->write_idx = prepend_size;
    buf->p_sz = prepend_size;
    buf->refcount = 0;
    buf->src = NULL;
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x8159
jmp 0x8178
leaq 0x7044(%rip), %rdi      # 0xf1a4
leaq 0x7046(%rip), %rsi      # 0xf1ad
movl $0x20, %edx
leaq 0x7043(%rip), %rcx      # 0xf1b6
callq 0x2170
cmpq $0x0, -0x18(%rbp)
jb 0x8181
jmp 0x81a0
leaq 0x705b(%rip), %rdi      # 0xf1e3
leaq 0x701e(%rip), %rsi      # 0xf1ad
movl $0x21, %edx
leaq 0x701b(%rip), %rcx      # 0xf1b6
callq 0x2170
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x21f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x81d3
movq $0x0, -0x8(%rbp)
jmp 0x8259
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x21f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x820a
movq -0x28(%rbp), %rdi
callq 0x23f0
movq $0x0, -0x8(%rbp)
jmp 0x8259
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_release
void buf_release(struct buffer *buf)
{
    // 可以嵌套创建readonlyView, 都要检查 refcount
    assert(buf->refcount == 0);

    if (buf->src)
    {
        // 只读视图
        buf->src->refcount--;

        // 缓存 只读视图, 为 mysql 协议解析做的优化
        if (!buf->src->cache)
        {
            buf->src->cache = buf;
        }
        else
        {
            free(buf);
        }
    }
    else
    {
        // 常规 buffer
        free(buf->buf);
        if (buf->cache)
        {
            free(buf->cache);
        }
        free(buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x8289
jmp 0x82a8
leaq 0x6f65(%rip), %rdi      # 0xf1f5
leaq 0x6f16(%rip), %rsi      # 0xf1ad
movl $0x3b, %edx
leaq 0x6f65(%rip), %rcx      # 0xf208
callq 0x2170
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x82f3
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x82e8
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x38(%rax)
jmp 0x82f1
movq -0x8(%rbp), %rdi
callq 0x23f0
jmp 0x8321
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x23f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x8318
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x23f0
movq -0x8(%rbp), %rdi
callq 0x23f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_retrieveAsString
void buf_retrieveAsString(struct buffer *buf, size_t len, char *str)
{
    assert(str != NULL);
    memcpy(str, buf_peek(buf), len);
    str[len] = 0;
    buf_retrieve(buf, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x868d
jmp 0x86ac
leaq 0x6c39(%rip), %rdi      # 0xf2cd
leaq 0x6b12(%rip), %rsi      # 0xf1ad
movl $0x99, %edx
leaq 0x6c32(%rip), %rcx      # 0xf2d9
callq 0x2170
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x2240
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x86f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_retrieve
void buf_retrieve(struct buffer *buf, size_t len)
{
    assert(len <= buf_readable(buf));
    if (len < buf_readable(buf))
    {
        buf->read_idx += len;
    }
    else
    {
        buf_retrieveAll(buf);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
ja 0x871f
jmp 0x873e
leaq 0x6b8b(%rip), %rdi      # 0xf2b1
leaq 0x6a80(%rip), %rsi      # 0xf1ad
movl $0xa7, %edx
leaq 0x6bdb(%rip), %rcx      # 0xf314
callq 0x2170
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x876b
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x8774
movq -0x8(%rbp), %rdi
callq 0x8780
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_ensureWritable
void buf_ensureWritable(struct buffer *buf, size_t len)
{
    ASSERT_WRITE(buf);
    if (buf_writable(buf) < len)
    {
        buf_makeSpace(buf, len);
    }
    assert(buf_writable(buf) >= len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8500
testb $0x1, %al
jne 0x88ff
jmp 0x891e
leaq 0x696b(%rip), %rdi      # 0xf271
leaq 0x68a0(%rip), %rsi      # 0xf1ad
movl $0xee, %edx
leaq 0x6a8c(%rip), %rcx      # 0xf3a5
callq 0x2170
movq -0x8(%rbp), %rdi
callq 0x8350
cmpq -0x10(%rbp), %rax
jae 0x893a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8970
movq -0x8(%rbp), %rdi
callq 0x8350
cmpq -0x10(%rbp), %rax
jb 0x894b
jmp 0x896a
leaq 0x6a84(%rip), %rdi      # 0xf3d6
leaq 0x6854(%rip), %rsi      # 0xf1ad
movl $0xf3, %edx
leaq 0x6a40(%rip), %rcx      # 0xf3a5
callq 0x2170
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_makeSpace
static void buf_makeSpace(struct buffer *buf, size_t len)
{
    size_t readable = buf_readable(buf);
    if (buf_prependable(buf) + buf_writable(buf) - buf->p_sz < len)
    {
        size_t nsz = buf->write_idx + len;
        buf_swap(buf, nsz);
    }
    else
    {
        assert(buf->p_sz < buf->read_idx);
        memmove(buf->buf + buf->p_sz, buf_peek(buf), readable);
    }

    buf->read_idx = buf->p_sz;
    buf->write_idx = buf->p_sz + readable;
    assert(readable == buf_readable(buf));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8390
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8350
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq 0x18(%rcx), %rax
cmpq -0x10(%rbp), %rax
jae 0x89da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8c30
jmp 0x8a39
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x89ed
jmp 0x8a0c
leaq 0x6d98(%rip), %rdi      # 0xf78c
leaq 0x67b2(%rip), %rsi      # 0xf1ad
movl $0xe3, %edx
leaq 0x6d9f(%rip), %rcx      # 0xf7a6
callq 0x2170
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x22f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x8a7b
jmp 0x8a9a
leaq 0x6d50(%rip), %rdi      # 0xf7d2
leaq 0x6724(%rip), %rsi      # 0xf1ad
movl $0xe9, %edx
leaq 0x6d11(%rip), %rcx      # 0xf7a6
callq 0x2170
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_append
void buf_append(struct buffer *buf, const char *data, size_t len)
{
    ASSERT_WRITE(buf);
    buf_ensureWritable(buf, len);
    memcpy(buf_beginWrite(buf), data, len);
    buf_has_written(buf, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8500
testb $0x1, %al
jne 0x8ac3
jmp 0x8ae2
leaq 0x67a7(%rip), %rdi      # 0xf271
leaq 0x66dc(%rip), %rsi      # 0xf1ad
movl $0xf8, %edx
leaq 0x6912(%rip), %rcx      # 0xf3ef
callq 0x2170
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x88e0
movq -0x8(%rbp), %rdi
callq 0x83d0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2240
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x83f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_swap
static void buf_swap(struct buffer *buf, size_t nsz)
{
    // TODO nsz > buf->size realloc ?
    assert(nsz >= buf_readable(buf));
    void *nbuf = calloc(1, nsz);
    assert(nbuf);
    memcpy(nbuf + buf->p_sz, buf_peek(buf), buf_readable(buf));
    free(buf->buf);
    buf->buf = nbuf;
    buf->sz = nsz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jb 0x8c5f
jmp 0x8c7e
leaq 0x6b8a(%rip), %rdi      # 0xf7f0
leaq 0x6540(%rip), %rsi      # 0xf1ad
movl $0xd0, %edx
leaq 0x6b90(%rip), %rcx      # 0xf809
callq 0x2170
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x21f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8c99
jmp 0x8cb8
leaq 0x6b90(%rip), %rdi      # 0xf830
leaq 0x6506(%rip), %rsi      # 0xf1ad
movl $0xd2, %edx
leaq 0x6b56(%rip), %rcx      # 0xf809
callq 0x2170
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x18(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x2240
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x23f0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt64
int64_t buf_peekInt64(const struct buffer *buf)
{
    assert(buf_readable(buf) >= sizeof(int64_t));
    int64_t be64 = 0;
    memcpy(&be64, buf_peek(buf), sizeof(int64_t));
    return be64toh(be64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x8, %rax
jb 0x91fd
jmp 0x921c
leaq 0x629f(%rip), %rdi      # 0xf4a3
leaq 0x5fa2(%rip), %rsi      # 0xf1ad
movl $0x15f, %edx            # imm = 0x15F
leaq 0x62b1(%rip), %rcx      # 0xf4c8
callq 0x2170
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt32
int32_t buf_peekInt32(const struct buffer *buf)
{
    assert(buf_readable(buf) >= sizeof(int32_t));
    int32_t be32 = 0;
    memcpy(&be32, buf_peek(buf), sizeof(int32_t));
    return be32toh(be32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x4, %rax
jb 0x926d
jmp 0x928c
leaq 0x6281(%rip), %rdi      # 0xf4f5
leaq 0x5f32(%rip), %rsi      # 0xf1ad
movl $0x167, %edx            # imm = 0x167
leaq 0x6293(%rip), %rcx      # 0xf51a
callq 0x2170
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x8e50
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt16
int16_t buf_peekInt16(const struct buffer *buf)
{
    assert(buf_readable(buf) >= sizeof(int16_t));
    int16_t be16 = 0;
    memcpy(&be16, buf_peek(buf), sizeof(int16_t));
    return be16toh(be16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x2, %rax
jb 0x92cd
jmp 0x92ec
leaq 0x6273(%rip), %rdi      # 0xf547
leaq 0x5ed2(%rip), %rsi      # 0xf1ad
movl $0x16f, %edx            # imm = 0x16F
leaq 0x6285(%rip), %rcx      # 0xf56c
callq 0x2170
movw $0x0, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x8ed0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt64LE
int64_t buf_peekInt64LE(const struct buffer *buf)
{
    assert(buf_readable(buf) >= sizeof(int64_t));
    int64_t le64 = 0;
    memcpy(&le64, buf_peek(buf), sizeof(int64_t));
    return le64toh(le64);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x8, %rax
jb 0x938d
jmp 0x93ac
leaq 0x610f(%rip), %rdi      # 0xf4a3
leaq 0x5e12(%rip), %rsi      # 0xf1ad
movl $0x17d, %edx            # imm = 0x17D
leaq 0x6241(%rip), %rcx      # 0xf5e8
callq 0x2170
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt32LE
int32_t buf_peekInt32LE(const struct buffer *buf)
{
    assert(buf_readable(buf) >= sizeof(int32_t));
    int32_t le32 = 0;
    memcpy(&le32, buf_peek(buf), sizeof(int32_t));
    return le32toh(le32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x4, %rax
jb 0x93fd
jmp 0x941c
leaq 0x60f1(%rip), %rdi      # 0xf4f5
leaq 0x5da2(%rip), %rsi      # 0xf1ad
movl $0x185, %edx            # imm = 0x185
leaq 0x6200(%rip), %rcx      # 0xf617
callq 0x2170
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x8fc0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt32LE24
int32_t buf_peekInt32LE24(const struct buffer *buf)
{
    assert(buf_readable(buf) >= 3);
    int32_t le32 = 0x00000000; /* 0x000000{00 小端高位未使用} */
    memcpy(&le32, buf_peek(buf), 3);
    return le32toh(le32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x3, %rax
jb 0x945d
jmp 0x947c
leaq 0x61e2(%rip), %rdi      # 0xf646
leaq 0x5d42(%rip), %rsi      # 0xf1ad
movl $0x18d, %edx            # imm = 0x18D
leaq 0x61e6(%rip), %rcx      # 0xf65d
callq 0x2170
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movw (%rax), %cx
movw %cx, -0xc(%rbp)
movb 0x2(%rax), %al
movb %al, -0xa(%rbp)
movl -0xc(%rbp), %edi
callq 0x8fc0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_peekInt16LE
int16_t buf_peekInt16LE(const struct buffer *buf)
{
    assert(buf_readable(buf) >= sizeof(int16_t));
    int16_t le16 = 0;
    memcpy(&le16, buf_peek(buf), sizeof(int16_t));
    return le16toh(le16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
cmpq $0x2, %rax
jb 0x94cd
jmp 0x94ec
leaq 0x6073(%rip), %rdi      # 0xf547
leaq 0x5cd2(%rip), %rsi      # 0xf1ad
movl $0x195, %edx            # imm = 0x195
leaq 0x61a7(%rip), %rcx      # 0xf68e
callq 0x2170
movw $0x0, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movw (%rax), %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x9010
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_readCStr
char *buf_readCStr(struct buffer *buf, char *str, int sz)
{
    int sz1;
    const char *eos = buf_findChar(buf, '\0');

    if (eos == NULL)
    {
        sz1 = buf_readable(buf) + 1;
    }
    else
    {
        sz1 = eos - buf_peek(buf) + 1;
    }

    if (sz < sz1)
    {
        return NULL;
    }

    memcpy(str, buf_peek(buf), sz);
    if (eos == NULL)
    {
        buf_retrieve(buf, sz1 - 1);
    }
    else
    {
        buf_retrieve(buf, sz1);
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x85a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x96db
movq -0x10(%rbp), %rdi
callq 0x8330
addq $0x1, %rax
movl %eax, -0x20(%rbp)
jmp 0x96fd
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x970f
movq $0x0, -0x8(%rbp)
jmp 0x9760
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2240
cmpq $0x0, -0x28(%rbp)
jne 0x974b
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x86f0
jmp 0x9758
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x86f0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_readStr
char *buf_readStr(struct buffer *buf, char *str, int sz)
{
    if (buf_readable(buf) < sz)
    {
        sz = buf_readable(buf);
    }

    memcpy(str, buf_peek(buf), sz);
    str[sz] = '\0';

    buf_retrieve(buf, sz);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8330
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jae 0x97a1
movq -0x8(%rbp), %rdi
callq 0x8330
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2240
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86f0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_dupCStr
char *buf_dupCStr(struct buffer *buf)
{
    int sz;
    const char *eos = buf_findChar(buf, '\0');

    if (eos == NULL)
    {
        sz = buf_readable(buf) + 1;
    }
    else
    {
        sz = eos - buf_peek(buf) + 1;
    }

    char *str = calloc(sz, 1);
    if (str == NULL)
    {
        return NULL;
    }

    memcpy(str, buf_peek(buf), sz);
    if (eos == NULL)
    {
        buf_retrieve(buf, sz - 1);
    }
    else
    {
        buf_retrieve(buf, sz);
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x85a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9824
movq -0x10(%rbp), %rdi
callq 0x8330
addq $0x1, %rax
movl %eax, -0x14(%rbp)
jmp 0x9846
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0x21f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9869
movq $0x0, -0x8(%rbp)
jmp 0x98ba
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83b0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2240
cmpq $0x0, -0x20(%rbp)
jne 0x98a5
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x86f0
jmp 0x98b2
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_dupStr
char *buf_dupStr(struct buffer *buf, int sz)
{
    if (buf_readable(buf) < sz)
    {
        sz = buf_readable(buf);
    }
    char *str = malloc(sz + 1);
    if (str == NULL)
    {
        return NULL;
    }

    memcpy(str, buf_peek(buf), sz);
    str[sz] = '\0';

    buf_retrieve(buf, sz);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8330
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jae 0x98fd
movq -0x10(%rbp), %rdi
callq 0x8330
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x23f8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9920
movq $0x0, -0x8(%rbp)
jmp 0x9962
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x2240
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x86f0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_readFd
ssize_t buf_readFd(struct buffer *buf, int fd, int *errno_)
{
    ASSERT_WRITE(buf);
    char extrabuf[65535];
    struct iovec vec[2];
    size_t writable = buf_writable(buf);
    vec[0].iov_base = buf_beginWrite(buf);
    vec[0].iov_len = writable;
    vec[1].iov_base = extrabuf;
    vec[1].iov_len = sizeof(extrabuf);

    int iovcnt = writable < sizeof(extrabuf) ? 2 : 1;
    ssize_t n = readv(fd, vec, iovcnt);
    if (n < 0)
    {
        *errno_ = n;
    }
    else if (n <= writable)
    {
        buf->write_idx += n;
    }
    else
    {
        buf->write_idx = buf->sz;
        buf_append(buf, (char *)(&extrabuf[0]), n - writable);
    }

    return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10060, %rsp          # imm = 0x10060
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8500
testb $0x1, %al
jne 0x9995
jmp 0x99b4
leaq 0x58d5(%rip), %rdi      # 0xf271
leaq 0x580a(%rip), %rsi      # 0xf1ad
movl $0x235, %edx            # imm = 0x235
leaq 0x5d0e(%rip), %rcx      # 0xf6bd
callq 0x2170
movq -0x8(%rbp), %rdi
callq 0x8350
movq %rax, -0x10048(%rbp)
movq -0x8(%rbp), %rdi
callq 0x83d0
movq %rax, -0x10040(%rbp)
movq -0x10048(%rbp), %rax
movq %rax, -0x10038(%rbp)
leaq -0x10020(%rbp), %rax
movq %rax, -0x10030(%rbp)
movq $0xffff, -0x10028(%rbp) # imm = 0xFFFF
movq -0x10048(%rbp), %rdx
movl $0x1, %eax
movl $0x2, %ecx
cmpq $0xffff, %rdx           # imm = 0xFFFF
cmovbl %ecx, %eax
movl %eax, -0x1004c(%rbp)
movl -0xc(%rbp), %edi
leaq -0x10040(%rbp), %rsi
movl -0x1004c(%rbp), %edx
callq 0x22e0
movq %rax, -0x10058(%rbp)
cmpq $0x0, -0x10058(%rbp)
jge 0x9a53
movq -0x10058(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x9aa8
movq -0x10058(%rbp), %rax
cmpq -0x10048(%rbp), %rax
ja 0x9a78
movq -0x10058(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x9aa6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
leaq -0x10020(%rbp), %rsi
movq -0x10058(%rbp), %rdx
subq -0x10048(%rbp), %rdx
callq 0x8aa0
jmp 0x9aa8
movq -0x10058(%rbp), %rax
addq $0x10060, %rsp          # imm = 0x10060
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/buffer.c
// Function: buf_readonlyView
struct buffer *buf_readonlyView(struct buffer *buf, int sz)
{
    assert(sz > 0);
    if (sz > buf_readable(buf))
    {
        sz = buf_readable(buf);
    }

    struct buffer *rbuf;

    if (buf->cache)
    {
        memset(buf->cache, 0, sizeof(*(buf->cache)));
        rbuf = buf->cache;
        buf->cache = NULL;
    }
    else
    {
        rbuf = calloc(1, sizeof(*buf));
        if (rbuf == NULL)
        {
            return NULL;
        }
    }

    rbuf->buf = buf->buf + buf->read_idx; // buf_peek(buf)
    rbuf->sz = sz;
    rbuf->read_idx = 0;
    rbuf->write_idx = sz;
    rbuf->p_sz = 0;
    rbuf->refcount = 0;
    rbuf->src = buf;
    buf->refcount++;
    return rbuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x9af7
jmp 0x9b16
leaq 0x5bef(%rip), %rdi      # 0xf6ed
leaq 0x56a8(%rip), %rsi      # 0xf1ad
movl $0x25d, %edx            # imm = 0x25D
leaq 0x5be3(%rip), %rcx      # 0xf6f4
callq 0x2170
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8330
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0x9b3f
movq -0x10(%rbp), %rdi
callq 0x8330
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x9b78
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2190
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
jmp 0x9b9e
movl $0x1, %edi
movl $0x40, %esi
callq 0x21f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9b9c
movq $0x0, -0x8(%rbp)
jmp 0x9c14
jmp 0x9b9e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_create_
static int socket_create_(bool nonblock)
{
#ifdef __APPLE__
    int sockfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
#else
    int sockfd = socket(PF_INET, SOCK_STREAM | (nonblock ? SOCK_NONBLOCK : 0) | SOCK_CLOEXEC, IPPROTO_TCP);
#endif

    if (sockfd < 0)
    {
        perror("ERROR socket");
        return -1;
    }

#ifdef __APPLE__
    if (nonblock)
    {
        socket_setNonblock(sockfd);
    }
#endif

    int yes = 1;
    setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes));
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
#ifdef SO_REUSEPORT
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes));
#endif
    setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &yes, sizeof(yes));

    // !! for server
    signal(SIGPIPE, SIG_IGN);
    return sockfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %cl
xorl %esi, %esi
movl $0x800, %eax            # imm = 0x800
testb $0x1, %cl
cmovnel %eax, %esi
orl $0x1, %esi
orl $0x80000, %esi          # imm = 0x80000
movl $0x2, %edi
movl $0x6, %edx
callq 0x23e0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0xa169
leaq 0x58cd(%rip), %rdi      # 0xfa25
callq 0x2300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa1f5
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0xf, %edx
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
movl -0xc(%rbp), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x20a0
movl $0xd, %edi
movl $0x1, %esi
callq 0x2210
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_bind
bool socket_bind(int sockfd, const union sockaddr_all *addr, socklen_t addrlen)
{
    if (bind(sockfd, (struct sockaddr *)addr, addrlen) < 0)
    {
        close(sockfd);
        perror("ERROR bind");
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rsi
callq 0x22d0
cmpl $0x0, %eax
jge 0xa258
movl -0x8(%rbp), %edi
callq 0x21a0
leaq 0x578f(%rip), %rdi      # 0xf9dc
callq 0x2300
movb $0x0, -0x1(%rbp)
jmp 0xa25c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_listen
bool socket_listen(int sockfd)
{
    // SOMAXCONN net.core.somaxconn linux 最大backlog值
    if (listen(sockfd, SOMAXCONN) < 0)
    {
        perror("ERROR listen");
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2290
cmpl $0x0, %eax
jge 0xa29f
leaq 0x5753(%rip), %rdi      # 0xf9e7
callq 0x2300
movb $0x0, -0x1(%rbp)
jmp 0xa2a3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_accept_
static int socket_accept_(int sockfd, union sockaddr_all *addr, socklen_t *addrlen, bool nonblock)
{
#ifdef __APPLE__
    int connfd = accept(sockfd, (struct sockaddr *)addr, addrlen);
#else
    int connfd = accept4(sockfd, (struct sockaddr *)addr, addrlen, (nonblock ? SOCK_NONBLOCK : 0) | SOCK_CLOEXEC);
#endif
    if (connfd < 0)
    {
        int savedErrno = errno;
        switch (savedErrno)
        {
        case EAGAIN:
        case ECONNABORTED:
        case EINTR:
        case EPROTO:
        case EPERM:
        case EMFILE:
            errno = savedErrno;
            break;
        case EBADF:
        case EFAULT:
        case EINVAL:
        case ENFILE:
        case ENOBUFS:
        case ENOMEM:
        case ENOTSOCK:
        case EOPNOTSUPP:
            perror("ERROR accept, unexpected error");
            return -1;
        default:
            perror("ERROR accept, unknown error");
            return -1;
        }
    }

#ifdef __APPLE__
    if (nonblock)
    {
        socket_setNonblock(sockfd);
    }
#endif

    return connfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %sil
xorl %ecx, %ecx
movl $0x800, %eax            # imm = 0x800
testb $0x1, %sil
cmovnel %eax, %ecx
orl $0x80000, %ecx          # imm = 0x80000
movq -0x28(%rbp), %rsi
callq 0x20f0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0xa39f
callq 0x2050
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0x68, %eax
ja 0xa388
movq -0x38(%rbp), %rax
leaq 0x54e0(%rip), %rcx      # 0xf838
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x2050
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xa39d
leaq 0x56b8(%rip), %rdi      # 0xfa32
callq 0x2300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3a5
leaq 0x56c2(%rip), %rdi      # 0xfa51
callq 0x2300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3a5
jmp 0xa39f
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_sendAllSync
size_t socket_sendAllSync(int sockfd, const char *buf, size_t size)
{
    size_t sent = 0;
    while (sent < size)
    {
        ssize_t n = send(sockfd, buf + sent, size - sent, 0);
        if (n == -1)
        {
            if (errno == EINTR)
            {
                continue;
            }
            else
            {
                perror("ERROR send");
                break;
            }
        }
        sent += n;
    }

    return sent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa572
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2110
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xa564
callq 0x2050
cmpl $0x4, (%rax)
jne 0xa556
jmp 0xa51b
leaq 0x54b2(%rip), %rdi      # 0xfa0f
callq 0x2300
jmp 0xa572
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xa51b
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_recvAllSync
size_t socket_recvAllSync(int sockfd, char *buf, size_t size)
{
    size_t recved = 0;
    while (recved < size)
    {
        ssize_t n = recv(sockfd, buf + recved, size - recved, 0);
        if (n == -1)
        {
            if (errno == EINTR)
            {
                continue;
            }
            else
            {
                perror("ERROR recv");
                recved = -1;
                break;
            }
        }
        else if (n == 0)
        {
            break; // EOF
        }
        else
        {
            recved += n;
        }
    }

    return recved;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xa605
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x2040
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xa5ec
callq 0x2050
cmpl $0x4, (%rax)
jne 0xa5d6
jmp 0xa59b
leaq 0x543d(%rip), %rdi      # 0xfa1a
callq 0x2300
movq $-0x1, -0x20(%rbp)
jmp 0xa605
cmpq $0x0, -0x28(%rbp)
jne 0xa5f5
jmp 0xa605
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xa603
jmp 0xa59b
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/socket.c
// Function: socket_getError
int socket_getError(int sockfd)
{
    int optval;
    int len = sizeof(optval);
    if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &optval, (socklen_t *)&len) < 0)
    {
        return errno;
    }
    else
    {
        return optval;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x4, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0xc(%rbp), %rcx
leaq -0x10(%rbp), %r8
callq 0x21e0
cmpl $0x0, %eax
jge 0xa64d
callq 0x2050
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xa653
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/sa.c
// Function: sa_create
union sockaddr_all
sa_create(uint16_t port, bool loopback_only)
{
    union sockaddr_all u;
    memset(&u, 0, sizeof(u));
    u.v4.sin_family = AF_INET;
    in_addr_t addr = loopback_only ? INADDR_LOOPBACK : INADDR_ANY;
    u.v4.sin_addr.s_addr = htonl(addr);
    u.v4.sin_port = htons(port);
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movb %dl, %al
movw %si, %cx
movq %rdi, %rdx
movq %rdx, -0x10(%rbp)
movw %cx, -0x2(%rbp)
andb $0x1, %al
movb %al, -0x3(%rbp)
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2190
movq -0x18(%rbp), %rdi
movw $0x2, (%rdi)
movb -0x3(%rbp), %dl
xorl %eax, %eax
movl $0x7f000001, %ecx       # imm = 0x7F000001
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x2180
movq -0x18(%rbp), %rdi
movl %eax, 0x4(%rdi)
movzwl -0x2(%rbp), %edi
callq 0x2100
movq -0x18(%rbp), %rdi
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x2(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/sa.c
// Function: sa_createV6
union sockaddr_all
sa_createV6(uint16_t port, bool loopback_only)
{
    union sockaddr_all u;
    memset(&u, 0, sizeof(u));
    u.v6.sin6_family = AF_INET6;
    u.v6.sin6_addr = loopback_only ? in6addr_loopback : in6addr_any;
    u.v6.sin6_port = htons(port);
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movb %dl, %al
movw %si, %cx
movq %rdi, %rdx
movq %rdx, -0x20(%rbp)
movw %cx, -0x2(%rbp)
andb $0x1, %al
movb %al, -0x3(%rbp)
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2190
movq -0x18(%rbp), %rdi
movw $0xa, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x10(%rbp)
testb $0x1, -0x3(%rbp)
je 0xa73f
movq -0x10(%rbp), %rax
movq 0xa891(%rip), %rcx      # 0x14fc0
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xa758
movq -0x10(%rbp), %rax
movq 0xa86e(%rip), %rcx      # 0x14fb8
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movzwl -0x2(%rbp), %edi
callq 0x2100
movq -0x18(%rbp), %rcx
movw %ax, %dx
movq -0x20(%rbp), %rax
movw %dx, 0x2(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/sa.c
// Function: sa_fromip
union sockaddr_all
sa_fromip(const char *ip, uint16_t port)
{
    union sockaddr_all u;
    memset(&u, 0, sizeof(u));
    u.v4.sin_family = AF_INET;
    if (inet_pton(AF_INET, ip, &(u.v4.sin_addr)) <= 0)
    {
        fprintf(stderr, "ERROR inet_pton %s", ip);
    }
    u.v4.sin_port = htons(port);
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movw %dx, %ax
movq %rdi, %rcx
movq %rcx, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2190
movq -0x18(%rbp), %rdx
movw $0x2, (%rdx)
movq -0x8(%rbp), %rsi
addq $0x4, %rdx
movl $0x2, %edi
callq 0x2250
cmpl $0x0, %eax
jg 0xa7e6
movq 0xa827(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x534b(%rip), %rsi      # 0xfb2a
movb $0x0, %al
callq 0x2220
movzwl -0xa(%rbp), %edi
callq 0x2100
movq -0x18(%rbp), %rcx
movw %ax, %dx
movq -0x20(%rbp), %rax
movw %dx, 0x2(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/goghcrow[P]dubbo_ab/sa.c
// Function: sa_fromipV6
union sockaddr_all
sa_fromipV6(const char *ip, uint16_t port)
{
    union sockaddr_all u;
    memset(&u, 0, sizeof(u));
    u.v6.sin6_family = AF_INET6;
    if (inet_pton(AF_INET6, ip, &(u.v6.sin6_addr)) <= 0)
    {
        fprintf(stderr, "ERROR inet_pton %s", ip);
    }
    u.v6.sin6_port = htons(port);
    return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movw %dx, %ax
movq %rdi, %rcx
movq %rcx, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2190
movq -0x18(%rbp), %rdx
movw $0xa, (%rdx)
movq -0x8(%rbp), %rsi
addq $0x8, %rdx
movl $0xa, %edi
callq 0x2250
cmpl $0x0, %eax
jg 0xa876
movq 0xa797(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x52bb(%rip), %rsi      # 0xfb2a
movb $0x0, %al
callq 0x2220
movzwl -0xa(%rbp), %edi
callq 0x2100
movq -0x18(%rbp), %rcx
movw %ax, %dx
movq -0x20(%rbp), %rax
movw %dx, 0x2(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)