LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: at_handshake
int at_handshake()
{
    int i;
    int err = 0;

    if (0 != pthread_equal(s_tid_reader, pthread_self())) {
        /* cannot be called from reader thread */
        return AT_ERROR_INVALID_THREAD;
    }

    pthread_mutex_lock(&cm_command_mutex);

    for (i = 0 ; i < HANDSHAKE_RETRY_COUNT ; i++) {
        /* some stacks start with verbose off */
        err = at_send_command_full_nolock ("ATE0Q0V1", NO_RESULT,
                    NULL, NULL, HANDSHAKE_TIMEOUT_MSEC, NULL);

        if (err == 0) {
            break;
        }
    }

    pthread_mutex_unlock(&cm_command_mutex);

    if (err == 0) {
        /* pause for a bit to let the input buffer drain any unmatched OK's
           (they will appear as extraneous unsolicited responses) */

        sleepMsec(HANDSHAKE_TIMEOUT_MSEC);
    }

    return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movq 0x12062(%rip), %rax     # 0x39148
movq %rax, -0x18(%rbp)
callq 0x5410
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x5400
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x2710c
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x2717e
leaq 0x10cfd(%rip), %rdi     # 0x37e10
callq 0x5570
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0x2715c
leaq 0x9741(%rip), %rdi      # 0x3086d
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3e8, %r8d            # imm = 0x3E8
movq %r9, %rdx
movq %r9, %rcx
callq 0x27190
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2714f
jmp 0x2715c
jmp 0x27151
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2711f
leaq 0x10cad(%rip), %rdi     # 0x37e10
callq 0x5350
cmpl $0x0, -0xc(%rbp)
jne 0x27178
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x27310
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: sleepMsec
static void sleepMsec(long long msec)
{
    struct timespec ts;
    int err;

    ts.tv_sec = (msec / 1000);
    ts.tv_nsec = (msec % 1000) * 1000 * 1000;

    do {
        err = nanosleep (&ts, &ts);
    } while (err < 0 && errno == EINTR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
imulq $0x3e8, %rdx, %rax      # imm = 0x3E8
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rsi
movq %rsi, %rdi
callq 0x51d0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0x27376
callq 0x5070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x2734e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: at_get_cme_error
AT_CME_Error at_get_cme_error(const ATResponse *p_response)
{
    int ret;
    int err;
    char *p_cur;

    if (p_response == NULL)
        return CME_ERROR_NON_CME;

    if (p_response->success > 0) {
        return CME_SUCCESS;
    }

    if (p_response->finalResponse == NULL
        || !strStartsWith(p_response->finalResponse, "+CME ERROR:")
    ) {
        return CME_ERROR_NON_CME;
    }

    p_cur = p_response->finalResponse;
    err = at_tok_start(&p_cur);

    if (err < 0) {
        return CME_ERROR_NON_CME;
    }

    err = at_tok_nextint(&p_cur, &ret);

    if (err < 0) {
        return CME_ERROR_NON_CME;
    }

    return (AT_CME_Error) ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x273af
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2743a
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x273c1
movl $0x0, -0x4(%rbp)
jmp 0x2743a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x273e5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x949b(%rip), %rsi      # 0x30876
callq 0x26a30
cmpl $0x0, %eax
jne 0x273ee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2743a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x284e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x27415
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2743a
leaq -0x20(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x28550
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x27434
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2743a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: isSMSUnsolicited
static int isSMSUnsolicited(const char *line)
{
    size_t i;

    for (i = 0 ; i < NUM_ELEMS(s_smsUnsoliciteds) ; i++) {
        if (strStartsWith(line, s_smsUnsoliciteds[i])) {
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x4, -0x18(%rbp)
jae 0x274e1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0xffa6(%rip), %rax      # 0x37460
movq (%rax,%rcx,8), %rsi
callq 0x26a30
cmpl $0x0, %eax
je 0x274d1
movl $0x1, -0x4(%rbp)
jmp 0x274e8
jmp 0x274d3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x274a4
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/Carton32[P]quectel-CM/atchannel.c
// Function: findNextEOL
static char * findNextEOL(char *cur)
{
    if (cur[0] == '>' && cur[1] == ' ' && cur[2] == '\0') {
        /* SMS prompt character...not \r terminated */
        return cur+2;
    }

    // Find next newline
    while (*cur != '\0' && *cur != '\r' && *cur != '\n') cur++;

    return *cur == '\0' ? NULL : cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3e, %eax
jne 0x27cbc
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x20, %eax
jne 0x27cbc
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x27cbc
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x27d2b
jmp 0x27cbe
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x27cf0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xd, %ecx
movb %al, -0x11(%rbp)
je 0x27cf0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x27cf9
jmp 0x27d07
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x27cbe
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x27d1b
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x27d23
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: writeraw
static int writeraw (const char *s, size_t len) {
    size_t cur = 0;
    ssize_t written;

    if (s_fd < 0 || s_readerClosed > 0) {
        return AT_ERROR_CHANNEL_CLOSED;
    }

    /* the main string */
    while (cur < len) {
        struct pollfd pollfds[1] = {{s_fd, POLLOUT, 0}};
        int ret;

        ret = poll(pollfds, 1, -1);
        if (ret <= 0)
            break;
            
        do {
            written = write (s_fd, s + cur, len - cur);
        } while (written < 0 && errno == EINTR);

        if (written < 0) {
            return AT_ERROR_GENERIC;
        }

        cur += written;
    }

    if (written < 0) {
        return AT_ERROR_GENERIC;
    }

    return cur;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x0, 0xf6b1(%rip)      # 0x37440
jl 0x27d9a
cmpl $0x0, 0x11390(%rip)     # 0x39128
jle 0x27da6
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x27e63
jmp 0x27da8
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x27e4c
movl 0xf684(%rip), %eax      # 0x37440
movl %eax, -0x30(%rbp)
movw $0x4, -0x2c(%rbp)
movw $0x0, -0x2a(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x53d0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jg 0x27de9
jmp 0x27e4c
jmp 0x27deb
movl 0xf64f(%rip), %edi      # 0x37440
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
callq 0x5100
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x35(%rbp)
jge 0x27e24
callq 0x5070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x27deb
cmpq $0x0, -0x28(%rbp)
jge 0x27e3b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27e63
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x27da8
cmpq $0x0, -0x28(%rbp)
jge 0x27e5c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27e63
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: isFinalResponseSuccess
static int isFinalResponseSuccess(const char *line)
{
    size_t i;

    for (i = 0 ; i < NUM_ELEMS(s_finalResponsesSuccess) ; i++) {
        if (strStartsWith(line, s_finalResponsesSuccess[i])) {
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x27ec1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0xf5e6(%rip), %rax      # 0x37480
movq (%rax,%rcx,8), %rsi
callq 0x26a30
cmpl $0x0, %eax
je 0x27eb1
movl $0x1, -0x4(%rbp)
jmp 0x27ec8
jmp 0x27eb3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27e84
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/Carton32[P]quectel-CM/atchannel.c
// Function: isFinalResponseError
static int isFinalResponseError(const char *line)
{
    size_t i;

    for (i = 0 ; i < NUM_ELEMS(s_finalResponsesError) ; i++) {
        if (strStartsWith(line, s_finalResponsesError[i])) {
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x7, -0x18(%rbp)
jae 0x27f71
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0xf556(%rip), %rax      # 0x374a0
movq (%rax,%rcx,8), %rsi
callq 0x26a30
cmpl $0x0, %eax
je 0x27f61
movl $0x1, -0x4(%rbp)
jmp 0x27f78
jmp 0x27f63
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27f34
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/Carton32[P]quectel-CM/atchannel.c
// Function: writeCtrlZ
static int writeCtrlZ (const char *s)
{
    size_t cur = 0;
    size_t len = strlen(s);
    ssize_t written;

    if (s_fd < 0 || s_readerClosed > 0) {
        return AT_ERROR_CHANNEL_CLOSED;
    }

    LOGD("AT> %s^Z", s);

    AT_DUMP( ">* ", s, strlen(s) );

    /* the main string */
    while (cur < len) {
        do {
            written = write (s_fd, s + cur, len - cur);
        } while (written < 0 && errno == EINTR);

        if (written < 0) {
            return AT_ERROR_GENERIC;
        }

        cur += written;
    }

    /* the ^Z  */

    do {
        written = write (s_fd, "\032" , 1);
    } while ((written < 0 && errno == EINTR) || (written == 0));

    if (written < 0) {
        return AT_ERROR_GENERIC;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movq %rax, -0x20(%rbp)
cmpl $0x0, 0xf488(%rip)      # 0x37440
jl 0x27fc3
cmpl $0x0, 0x11167(%rip)     # 0x39128
jle 0x27fcf
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x28107
jmp 0x27fd1
movq 0xf008(%rip), %rax      # 0x36fe0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x13930
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
leaq 0x899d(%rip), %rsi      # 0x30993
movb $0x0, %al
callq 0x52c0
leaq 0xfe64(%rip), %rax      # 0x37e68
cmpq $0x0, (%rax)
je 0x28036
leaq 0xfe57(%rip), %rax      # 0x37e68
movq (%rax), %rax
movq %rax, -0x38(%rbp)
callq 0x13930
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
leaq 0x8964(%rip), %rsi      # 0x30993
movb $0x0, %al
callq 0x52c0
jmp 0x28038
jmp 0x2803a
jmp 0x2803c
jmp 0x2803e
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x280a8
jmp 0x2804a
movl 0xf3f0(%rip), %edi      # 0x37440
movq -0x10(%rbp), %rsi
addq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
subq -0x18(%rbp), %rdx
callq 0x5100
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x39(%rbp)
jge 0x28083
callq 0x5070
cmpl $0x4, (%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2804a
cmpq $0x0, -0x28(%rbp)
jge 0x2809a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x28107
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x2803e
jmp 0x280aa
movl 0xf390(%rip), %edi      # 0x37440
leaq 0x88eb(%rip), %rsi      # 0x309a2
movl $0x1, %edx
callq 0x5100
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x280de
callq 0x5070
movq %rax, %rcx
movb $0x1, %al
cmpl $0x4, (%rcx)
movb %al, -0x3a(%rbp)
je 0x280e9
cmpq $0x0, -0x28(%rbp)
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x280aa
cmpq $0x0, -0x28(%rbp)
jge 0x28100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x28107
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: addIntermediate
static void addIntermediate(const char *line)
{
    ATLine *p_new;

    p_new = (ATLine  *) malloc(sizeof(ATLine));

    p_new->line = strdup(line);

    /* note: this adds to the head of the list, so the list
       will be in reverse order of lines received. the order is flipped
       again before passing on to the command issuer */
    p_new->p_next = sp_response->p_intermediates;
    sp_response->p_intermediates = p_new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x5370
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5530
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10ffb(%rip), %rax     # 0x39140
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x10fe5(%rip), %rax     # 0x39140
movq %rcx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: onReaderClosed
static void onReaderClosed()
{
    LOGE("%s", __func__);
    if (s_onReaderClosed != NULL && s_readerClosed == 0) {

        pthread_mutex_lock(&cm_command_mutex);

        s_readerClosed = 1;

        pthread_cond_signal(&cm_command_cond);

        pthread_mutex_unlock(&cm_command_mutex);

        s_onReaderClosed();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x2817a
movq 0xee5f(%rip), %rax      # 0x36fe0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
callq 0x13930
movq -0x8(%rbp), %rdi
movq %rax, %rdx
leaq 0x3f13(%rip), %rsi      # 0x2c0ae
leaq 0x8802(%rip), %rcx      # 0x309a4
movb $0x0, %al
callq 0x52c0
leaq 0xfcb8(%rip), %rax      # 0x37e68
cmpq $0x0, (%rax)
je 0x281e5
leaq 0xfcab(%rip), %rax      # 0x37e68
movq (%rax), %rax
movq %rax, -0x10(%rbp)
callq 0x13930
movq -0x10(%rbp), %rdi
movq %rax, %rdx
leaq 0x3ed7(%rip), %rsi      # 0x2c0ae
leaq 0x87c6(%rip), %rcx      # 0x309a4
movb $0x0, %al
callq 0x52c0
jmp 0x281e7
cmpq $0x0, 0x10f79(%rip)     # 0x39168
je 0x2822e
cmpl $0x0, 0x10f30(%rip)     # 0x39128
jne 0x2822e
leaq 0xfc0f(%rip), %rdi      # 0x37e10
callq 0x5570
movl $0x1, 0x10f18(%rip)     # 0x39128
leaq 0xfc21(%rip), %rdi      # 0x37e38
callq 0x5280
leaq 0xfbed(%rip), %rdi      # 0x37e10
callq 0x5350
callq *0x10f3a(%rip)          # 0x39168
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: reverseIntermediates
static void reverseIntermediates(ATResponse *p_response)
{
    ATLine *pcur,*pnext;

    pcur = p_response->p_intermediates;
    p_response->p_intermediates = NULL;

    while (pcur != NULL) {
        pnext = pcur->p_next;
        pcur->p_next = p_response->p_intermediates;
        p_response->p_intermediates = pcur;
        pcur = pnext;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x28477
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x28440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/atchannel.c
// Function: clearPendingCommand
static void clearPendingCommand()
{
    if (sp_response != NULL) {
        at_response_free(sp_response);
    }

    sp_response = NULL;
    s_responsePrefix = NULL;
    s_smsPDU = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x10c94(%rip)     # 0x39140
je 0x284ba
movq 0x10c8b(%rip), %rdi     # 0x39140
callq 0x26d20
movq $0x0, 0x10c7b(%rip) # 0x39140
movq $0x0, 0x10c60(%rip) # 0x39130
movq $0x0, 0x10c5d(%rip) # 0x39138
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/at_tok.c
// Function: at_tok_start
int at_tok_start(char **p_cur)
{
    if (*p_cur == NULL) {
        return -1;
    }

    // skip prefix
    // consume "^[^:]:"

    *p_cur = strchr(*p_cur, ':');

    if (*p_cur == NULL) {
        return -1;
    }

    (*p_cur)++;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x284ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x28542
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0x3a, %esi
callq 0x5190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2852d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x28542
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/at_tok.c
// Function: at_tok_nextint_base
static int at_tok_nextint_base(char **p_cur, int *p_out, int base, int  uns)
{
    char *ret;

    if (*p_cur == NULL) {
        return -1;
    }

    ret = nextTok(p_cur);

    if (ret == NULL) {
        return -1;
    } else {
        long l;
        char *end;

        if (uns)
            l = strtoul(ret, &end, base);
        else
            l = strtol(ret, &end, base);

        *p_out = (int)l;

        if (end == ret) {
            return -1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x285a9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2861e
movq -0x10(%rbp), %rdi
callq 0x28720
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x285c6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2861e
cmpl $0x0, -0x20(%rbp)
je 0x285e2
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0x54b0
movq %rax, -0x30(%rbp)
jmp 0x285f6
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0x52e0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x28615
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2861e
jmp 0x28617
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/at_tok.c
// Function: at_tok_nextbool
int at_tok_nextbool(char **p_cur, char *p_out)
{
    int ret;
    int result;

    ret = at_tok_nextint(p_cur, &result);

    if (ret < 0) {
        return -1;
    }

    // booleans should be 0 or 1
    if (!(result == 0 || result == 1)) {
        return -1;
    }

    if (p_out != NULL) {
        *p_out = (char)result;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x28550
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2868f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x286bc
cmpl $0x0, -0x20(%rbp)
je 0x286a4
cmpl $0x1, -0x20(%rbp)
je 0x286a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x286bc
cmpq $0x0, -0x18(%rbp)
je 0x286b6
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/at_tok.c
// Function: at_tok_nextstr
int at_tok_nextstr(char **p_cur, char **p_out)
{
    if (*p_cur == NULL) {
        return -1;
    }

    *p_out = nextTok(p_cur);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x286f3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2870d
movq -0x10(%rbp), %rdi
callq 0x28720
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
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/Carton32[P]quectel-CM/at_tok.c
// Function: nextTok
static char * nextTok(char **p_cur)
{
    char *ret = NULL;

    skipWhiteSpace(p_cur);

    if (*p_cur == NULL) {
        ret = NULL;
    } else if (**p_cur == '"') {
        (*p_cur)++;
        ret = strsep(p_cur, "\"");
        skipNextComma(p_cur);
    } else {
        ret = strsep(p_cur, ",");
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28b30
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x28751
movq $0x0, -0x10(%rbp)
jmp 0x287a3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x2878d
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x7b2f(%rip), %rsi      # 0x302a8
callq 0x5390
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28bb0
jmp 0x287a1
movq -0x8(%rbp), %rdi
leaq 0x82a4(%rip), %rsi      # 0x30a3c
callq 0x5390
movq %rax, -0x10(%rbp)
jmp 0x287a3
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/at_tok.c
// Function: at_tok_count
int at_tok_count(const char *in_line)
{
    int commas = 0;
    const char *p;

    if (!in_line)
        return 0;

    for (p = in_line; *p != '\0' ; p++) {
        if (*p == ',') commas++;
    }

    return commas;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2880f
movl $0x0, -0x4(%rbp)
jmp 0x2884e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x28848
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x28838
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2883a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x28817
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/at_tok.c
// Function: skipNextComma
static void skipNextComma(char **p_cur)
{
    if (*p_cur == NULL) return;

    while (**p_cur != '\0' && **p_cur != ',') {
        (*p_cur)++;
    }

    if (**p_cur == ',') {
        (*p_cur)++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x28bc4
jmp 0x28c23
jmp 0x28bc6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
je 0x28bed
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x28bf6
jmp 0x28c06
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x28bc6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x28c23
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: ipv4Str
static const char *ipv4Str(const uint32_t Address) {
    static char str[] = {"255.225.255.255"};
    uint8_t *ip = (uint8_t *)&Address;

    snprintf(str, sizeof(str), "%d.%d.%d.%d", ip[3], ip[2], ip[1], ip[0]);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %ecx
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %r8d
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %r9d
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
leaq 0xe2c5(%rip), %rdi      # 0x374e0
movl $0x10, %esi
leaq 0x7309(%rip), %rdx      # 0x30530
movl %eax, (%rsp)
movb $0x0, %al
callq 0x51c0
leaq 0xe2a8(%rip), %rax      # 0x374e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: update_ipv6_address
void update_ipv6_address(const char *ifname, const char *ip, const char *gw, unsigned prefix) {
    char shell_cmd[128];

    (void)gw;
    if (!access("/sbin/ip", X_OK)) {
        snprintf(shell_cmd, sizeof(shell_cmd), "ip -%d address flush dev %s", 6, ifname);
        ql_system(shell_cmd);

        snprintf(shell_cmd, sizeof(shell_cmd), "ip -%d address add %s/%u dev %s", 6, ip, prefix, ifname);
        ql_system(shell_cmd);

        //ping6 www.qq.com
        snprintf(shell_cmd, sizeof(shell_cmd), "ip -%d route add default dev %s", 6, ifname);
        ql_system(shell_cmd);
    } else {
        snprintf(shell_cmd, sizeof(shell_cmd), "ifconfig %s %s/%d", ifname, ip, prefix);
        ql_system(shell_cmd);

        snprintf(shell_cmd, sizeof(shell_cmd), "route -A inet6 add default dev %s", ifname);
        ql_system(shell_cmd);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0x7838(%rip), %rdi      # 0x30a99
movl $0x1, %esi
callq 0x5460
cmpl $0x0, %eax
jne 0x2930f
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %r8
movl $0x80, %esi
leaq 0x7817(%rip), %rdx      # 0x30aa2
movl $0x6, %ecx
movb $0x0, %al
callq 0x51c0
leaq -0xa0(%rbp), %rdi
callq 0x28f30
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %r8
movl -0x1c(%rbp), %r9d
movq -0x8(%rbp), %rax
movl $0x80, %esi
leaq 0x77fc(%rip), %rdx      # 0x30abe
movl $0x6, %ecx
movq %rax, (%rsp)
movb $0x0, %al
callq 0x51c0
leaq -0xa0(%rbp), %rdi
callq 0x28f30
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %r8
movl $0x80, %esi
leaq 0x7862(%rip), %rdx      # 0x30b57
movl $0x6, %ecx
movb $0x0, %al
callq 0x51c0
leaq -0xa0(%rbp), %rdi
callq 0x28f30
jmp 0x2936b
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movl -0x1c(%rbp), %r9d
movl $0x80, %esi
leaq 0x7849(%rip), %rdx      # 0x30b77
movb $0x0, %al
callq 0x51c0
leaq -0xa0(%rbp), %rdi
callq 0x28f30
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x80, %esi
leaq 0x7831(%rip), %rdx      # 0x30b89
movb $0x0, %al
callq 0x51c0
leaq -0xa0(%rbp), %rdi
callq 0x28f30
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: ql_set_mtu
static void ql_set_mtu(const char *ifname, int ifru_mtu) {
    int inet_sock;
    struct ifreq ifr;

    inet_sock = socket(AF_INET, SOCK_DGRAM, 0);

    if (inet_sock > 0) {
        ifc_init_ifr(ifname, &ifr);

        if (!ioctl(inet_sock, SIOCGIFMTU, &ifr)) {
            if (ifr.ifr_ifru.ifru_mtu != ifru_mtu) {
                dbg_time("change mtu %d -> %d", ifr.ifr_ifru.ifru_mtu , ifru_mtu);
                ifr.ifr_ifru.ifru_mtu = ifru_mtu;
                ioctl(inet_sock, SIOCSIFMTU, &ifr);
            }
        }

        close(inet_sock);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x55a0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x29d51
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2a7d0
movl -0x10(%rbp), %edi
movl $0x8921, %esi           # imm = 0x8921
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x5210
cmpl $0x0, %eax
jne 0x29d49
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x29d47
jmp 0x29cc1
movq 0xd318(%rip), %rax      # 0x36fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x13930
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movl -0x28(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq 0x703d(%rip), %rsi      # 0x30d26
movb $0x0, %al
callq 0x52c0
leaq 0xe171(%rip), %rax      # 0x37e68
cmpq $0x0, (%rax)
je 0x29d2c
leaq 0xe164(%rip), %rax      # 0x37e68
movq (%rax), %rax
movq %rax, -0x48(%rbp)
callq 0x13930
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movl -0x28(%rbp), %ecx
movl -0xc(%rbp), %r8d
leaq 0x7001(%rip), %rsi      # 0x30d26
movb $0x0, %al
callq 0x52c0
jmp 0x29d2e
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x10(%rbp), %edi
movl $0x8922, %esi           # imm = 0x8922
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x5210
jmp 0x29d49
movl -0x10(%rbp), %edi
callq 0x5230
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: ifc_get_flags
static short ifc_get_flags(const char *ifname)
{
    int inet_sock;
    struct ifreq ifr;
    int ret = 0;

    inet_sock = socket(AF_INET, SOCK_DGRAM, 0);

    if (inet_sock > 0) {
        ifc_init_ifr(ifname, &ifr);

        if (!ioctl(inet_sock, SIOCGIFFLAGS, &ifr)) {
            ret = ifr.ifr_ifru.ifru_flags;
        }

        close(inet_sock);
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x55a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x29dbe
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2a7d0
movl -0xc(%rbp), %edi
movl $0x8913, %esi           # imm = 0x8913
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x5210
cmpl $0x0, %eax
jne 0x29db6
movswl -0x28(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0xc(%rbp), %edi
callq 0x5230
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: ipv6Str
static const char *ipv6Str(const UCHAR Address[16]) {
    static char str[64];
    uint16_t ip[8];
    int i;
    for (i = 0; i < 8; i++) {
        ip[i] = (Address[i*2]<<8) + Address[i*2+1];
    }

    snprintf(str, sizeof(str), "%x:%x:%x:%x:%x:%x:%x:%x",
        ip[0], ip[1], ip[2], ip[3], ip[4], ip[5], ip[6], ip[7]);

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x8, -0x34(%rbp)
jge 0x29e2b
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movl -0x34(%rbp), %edx
shll %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, %cx
movslq -0x34(%rbp), %rax
movw %cx, -0x30(%rbp,%rax,2)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x29de6
movzwl -0x30(%rbp), %ecx
movzwl -0x2e(%rbp), %r8d
movzwl -0x2c(%rbp), %r9d
movzwl -0x2a(%rbp), %r14d
movzwl -0x28(%rbp), %ebx
movzwl -0x26(%rbp), %r11d
movzwl -0x24(%rbp), %r10d
movzwl -0x22(%rbp), %eax
leaq 0xf779(%rip), %rdi      # 0x395d0
movl $0x40, %esi
leaq 0x6edd(%rip), %rdx      # 0x30d40
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x51c0
leaq 0xf749(%rip), %rax      # 0x395d0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: udhcpc_thread_function
static void* udhcpc_thread_function(void* arg) {
    FILE * udhcpc_fp;
    char *udhcpc_cmd = (char *)arg;

    if (udhcpc_cmd == NULL)
        return NULL;

    dbg_time("%s", udhcpc_cmd);
    udhcpc_fp = popen(udhcpc_cmd, "r");
    free(udhcpc_cmd);
    if (udhcpc_fp) {
        char buf[0xff];

        buf[sizeof(buf)-1] = '\0';
        while((fgets(buf, sizeof(buf)-1, udhcpc_fp)) != NULL) {
            if ((strlen(buf) > 1) && (buf[strlen(buf) - 1] == '\n'))
                buf[strlen(buf) - 1] = '\0';
            dbg_time("%s", buf);
        }

        pclose(udhcpc_fp);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2a11b
movq $0x0, -0x8(%rbp)
jmp 0x2a2b3
jmp 0x2a11d
movq 0xcebc(%rip), %rax      # 0x36fe0
movq (%rax), %rax
movq %rax, -0x128(%rbp)
callq 0x13930
movq -0x128(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0x1f66(%rip), %rsi      # 0x2c0ae
movb $0x0, %al
callq 0x52c0
leaq 0xdd12(%rip), %rax      # 0x37e68
cmpq $0x0, (%rax)
je 0x2a18e
leaq 0xdd05(%rip), %rax      # 0x37e68
movq (%rax), %rax
movq %rax, -0x130(%rbp)
callq 0x13930
movq -0x130(%rbp), %rdi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
leaq 0x1f27(%rip), %rsi      # 0x2c0ae
movb $0x0, %al
callq 0x52c0
jmp 0x2a190
movq -0x20(%rbp), %rdi
leaq 0x524c(%rip), %rsi      # 0x2f3e7
callq 0x5470
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5040
cmpq $0x0, -0x18(%rbp)
je 0x2a2ab
movb $0x0, -0x22(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xfe, %esi
callq 0x5270
cmpq $0x0, %rax
je 0x2a2a2
leaq -0x120(%rbp), %rdi
callq 0x5160
cmpq $0x1, %rax
jbe 0x2a222
leaq -0x120(%rbp), %rdi
callq 0x5160
subq $0x1, %rax
movsbl -0x120(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x2a222
leaq -0x120(%rbp), %rdi
callq 0x5160
subq $0x1, %rax
movb $0x0, -0x120(%rbp,%rax)
jmp 0x2a224
movq 0xcdb5(%rip), %rax      # 0x36fe0
movq (%rax), %rax
movq %rax, -0x138(%rbp)
callq 0x13930
movq -0x138(%rbp), %rdi
movq %rax, %rdx
leaq -0x120(%rbp), %rcx
leaq 0x1e5c(%rip), %rsi      # 0x2c0ae
movb $0x0, %al
callq 0x52c0
leaq 0xdc08(%rip), %rax      # 0x37e68
cmpq $0x0, (%rax)
je 0x2a29b
leaq 0xdbfb(%rip), %rax      # 0x37e68
movq (%rax), %rax
movq %rax, -0x140(%rbp)
callq 0x13930
movq -0x140(%rbp), %rdi
movq %rax, %rdx
leaq -0x120(%rbp), %rcx
leaq 0x1e1a(%rip), %rsi      # 0x2c0ae
movb $0x0, %al
callq 0x52c0
jmp 0x2a29d
jmp 0x2a1bc
movq -0x18(%rbp), %rdi
callq 0x51b0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: udhcpc_stop
void udhcpc_stop(PROFILE_T *profile) {
    char *ifname = profile->usbnet_adapter;
    char shell_cmd[128];

    ql_set_driver_link_state(profile, 0);

    if (profile->qmapnet_adapter[0]) {
        ifname = profile->qmapnet_adapter;
    }

#ifdef USE_DHCLIENT
    if (dhclient_alive) {
        system("killall dhclient");
        dhclient_alive = 0;
    }
#endif
    if (dibbler_client_alive) {
        if (system("killall dibbler-client")) {};
        dibbler_client_alive = 0;
    }

//it seems when call netif_carrier_on(), and netcard 's IP is "0.0.0.0", will cause netif_queue_stopped()
    snprintf(shell_cmd, sizeof(shell_cmd), "ifconfig %s 0.0.0.0", ifname);
    ql_system(shell_cmd);
    snprintf(shell_cmd, sizeof(shell_cmd), "ifconfig %s down", ifname);
    ql_system(shell_cmd);

#ifdef QL_OPENWER_NETWORK_SETUP
    ql_openwrt_setup_wan(ifname, NULL);
    ql_openwrt_setup_wan6(ifname, NULL);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xaa, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x28c30
movq -0x8(%rbp), %rax
cmpb $0x0, 0xca(%rax)
je 0x2a743
movq -0x8(%rbp), %rax
addq $0xca, %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xee76(%rip)      # 0x395c0
je 0x2a769
leaq 0x65a8(%rip), %rdi      # 0x30cfb
callq 0x5170
cmpl $0x0, %eax
je 0x2a75f
jmp 0x2a75f
movl $0x0, 0xee57(%rip)      # 0x395c0
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x80, %esi
leaq 0x6592(%rip), %rdx      # 0x30d12
movb $0x0, %al
callq 0x51c0
leaq -0x90(%rbp), %rdi
callq 0x28f30
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x80, %esi
leaq 0x62de(%rip), %rdx      # 0x30a88
movb $0x0, %al
callq 0x51c0
leaq -0x90(%rbp), %rdi
callq 0x28f30
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/udhcpc.c
// Function: ifc_get_addr
static int ifc_get_addr(const char *name, in_addr_t *addr)
{
    int inet_sock;
    struct ifreq ifr;
    int ret = 0;

    inet_sock = socket(AF_INET, SOCK_DGRAM, 0);

    ifc_init_ifr(name, &ifr);
    if (addr != NULL) {
        ret = ioctl(inet_sock, SIOCGIFADDR, &ifr);
        if (ret < 0) {
            *addr = 0;
        } else {
            *addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr;
        }
    }
    close(inet_sock);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x55a0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2a7d0
cmpq $0x0, -0x10(%rbp)
je 0x2a87f
movl -0x14(%rbp), %edi
movl $0x8915, %esi           # imm = 0x8915
leaq -0x40(%rbp), %rdx
movb $0x0, %al
callq 0x5210
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jge 0x2a874
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x2a87d
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0x2a87f
movl -0x14(%rbp), %edi
callq 0x5230
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/racer/racer.c
// Function: car_init
static void car_init(car_t *car, bool far_away)
{
  for (int i = 0; i < CARS_MAX; i++) {
    car->speed = 3 + (random() % 15);
    car->hpos = HPOS_MIN + (random() % (HPOS_MAX - HPOS_MIN));
    if (far_away) {
      car->distance = 1500 + (random() % 2500);
    } else {
      car->distance = 100 + (random() % 4000);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x5, -0x10(%rbp)
jge 0x1948
callq 0x1120
movl $0xf, %ecx
cqto
idivq %rcx
addq $0x3, %rdx
movl %edx, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
callq 0x1120
movl $0x46, %ecx
cqto
idivq %rcx
addq $-0x23, %rdx
movl %edx, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
testb $0x1, -0x9(%rbp)
je 0x1918
callq 0x1120
movl $0x9c4, %ecx            # imm = 0x9C4
cqto
idivq %rcx
addq $0x5dc, %rdx            # imm = 0x5DC
cvtsi2ss %rdx, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x1938
callq 0x1120
movl $0xfa0, %ecx            # imm = 0xFA0
cqto
idivq %rcx
addq $0x64, %rdx
cvtsi2ss %rdx, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x193a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x18ab
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/racer/racer.c
// Function: car_collision
static bool car_collision(car_t *car, int hpos)
{
  if (car->distance > 10) {
    return false;
  }

  if (car->distance < -10) {
    return false;
  }

  if (abs(car->hpos - hpos) > 12) {
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movss 0x1379(%rip), %xmm1     # 0x3044
ucomiss %xmm1, %xmm0
jbe 0x1cd6
movb $0x0, -0x1(%rbp)
jmp 0x1d0d
movq -0x10(%rbp), %rax
movss 0x1366(%rip), %xmm0     # 0x3048
ucomiss (%rax), %xmm0
jbe 0x1ced
movb $0x0, -0x1(%rbp)
jmp 0x1d0d
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
subl -0x14(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0xc, %eax
jle 0x1d09
movb $0x0, -0x1(%rbp)
jmp 0x1d0d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/racer/racer.c
// Function: curve_ahead
static int curve_ahead(int speed)
{
  static int curve_internal = 0;
  static float distance = 0;

  distance += speed;
  if (distance > 100) {
    curve_internal += (1 - random() % 3);
    if (curve_internal > 30) {
      curve_internal = 30;
    } else if (curve_internal < -30) {
      curve_internal = -30;
    }
    distance = 0;
  }

  return curve_internal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cvtsi2ssl -0x4(%rbp), %xmm0
addss 0x2370(%rip), %xmm0     # 0x50f8
movss %xmm0, 0x2368(%rip)     # 0x50f8
movss 0x2360(%rip), %xmm0     # 0x50f8
movss 0x294(%rip), %xmm1      # 0x3034
ucomiss %xmm1, %xmm0
jbe 0x2e01
callq 0x1120
movl $0x3, %ecx
cqto
idivq %rcx
movl $0x1, %ecx
subq %rdx, %rcx
movslq 0x2331(%rip), %rax      # 0x50f4
addq %rcx, %rax
movl %eax, 0x2328(%rip)      # 0x50f4
cmpl $0x1e, 0x2321(%rip)     # 0x50f4
jle 0x2de1
movl $0x1e, 0x2315(%rip)     # 0x50f4
jmp 0x2df6
cmpl $-0x1e, 0x230c(%rip)    # 0x50f4
jge 0x2df4
movl $0xffffffe2, 0x2300(%rip) # imm = 0xFFFFFFE2
jmp 0x2df6
xorps %xmm0, %xmm0
movss %xmm0, 0x22f7(%rip)     # 0x50f8
movl 0x22ed(%rip), %eax      # 0x50f4
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/too_many_clients.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(libforks_start(&conn) == libforks_OK);

  for (size_t i = 0; i < 19; i++) {
    libforks_Result r = libforks_fork(
      conn,
      NULL, // pid_ptr
      NULL, // socket_fd_ptr
      NULL, // exit_fd_ptr
      child_main
    );
    check(r == libforks_OK);
  }

  errno = ENOENT;
  libforks_Result r = libforks_fork(
    conn,
    NULL, // pid_ptr
    NULL, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  );
  check(errno == 0);
  check(r == libforks_TOO_MANY_CLIENTS_ERROR);

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1aa0
cmpl $0x0, %eax
jne 0x132f
jmp 0x1347
leaq 0x2cce(%rip), %rdi      # 0x4004
leaq 0x2cec(%rip), %rsi      # 0x4029
movl $0xe, %edx
callq 0x1440
movq $0x0, -0x18(%rbp)
cmpq $0x13, -0x18(%rbp)
jae 0x13a3
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x11b(%rip), %r8        # 0x1480
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x2270
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x137b
jmp 0x1393
leaq 0x2cc0(%rip), %rdi      # 0x4042
leaq 0x2ca0(%rip), %rsi      # 0x4029
movl $0x18, %edx
callq 0x1440
jmp 0x1395
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x134f
callq 0x1050
movl $0x2, (%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xc3(%rip), %r8         # 0x1480
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x2270
movl %eax, -0x20(%rbp)
callq 0x1050
cmpl $0x0, (%rax)
jne 0x13d7
jmp 0x13ef
leaq 0x2c75(%rip), %rdi      # 0x4053
leaq 0x2c44(%rip), %rsi      # 0x4029
movl $0x23, %edx
callq 0x1440
cmpl $-0x7, -0x20(%rbp)
jne 0x13f7
jmp 0x140f
leaq 0x2c60(%rip), %rdi      # 0x405e
leaq 0x2c24(%rip), %rsi      # 0x4029
movl $0x24, %edx
callq 0x1440
movq -0x10(%rbp), %rdi
callq 0x2500
cmpl $0x0, %eax
jne 0x141f
jmp 0x1437
leaq 0x2c5d(%rip), %rdi      # 0x4083
leaq 0x2bfc(%rip), %rsi      # 0x4029
movl $0x26, %edx
callq 0x1440
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stv0g[P]c11-queues/mpmc_test.c
// Function: thread_func
int thread_func(void *ctx)
{
	struct mpmc_queue *q = (struct mpmc_queue *) ctx;

	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();

	/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();

	for (int iter = 0; iter != iter_count; ++iter) {
		for (size_t i = 0; i != batch_size; i += 1) {
			void *ptr = (void *) i;
			while (!mpmc_queue_push(q, ptr))
				thrd_yield(); // queue full, let other threads proceed
		}

		for (size_t i = 0; i != batch_size; i += 1) {
			void *ptr;
			while (!mpmc_queue_pull(q, &ptr))
				thrd_yield(); // queue empty, let other threads proceed
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movl %eax, %eax
movq %rax, -0x50(%rbp)
callq 0x1200
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movl %eax, %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movslq %edx, %rax
movq %rax, -0x18(%rbp)
movl 0x2e31(%rip), %eax      # 0x4094
cmpl $0x0, %eax
jne 0x126f
callq 0x1350
jmp 0x125d
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x1291
pause
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1277
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x1e8480, %rax         # imm = 0x1E8480
je 0x1344
movq $0x0, -0x30(%rbp)
cmpq $0xa, -0x30(%rbp)
je 0x12f1
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1780
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12da
jmp 0x12e1
callq 0x1350
jmp 0x12bf
jmp 0x12e3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x12b0
movq $0x0, -0x40(%rbp)
cmpq $0xa, -0x40(%rbp)
je 0x1334
jmp 0x1302
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1890
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x131d
jmp 0x1324
callq 0x1350
jmp 0x1302
jmp 0x1326
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x12f9
jmp 0x1336
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1298
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonglfw/src/callbacks.c
// Function: ErrorCallback
static void ErrorCallback(int ec, const char* descr)
    {
    BEGIN(Error);
    lua_pushinteger(L, ec); /* @@ farne un enum? */ 
    lua_pushstring(L, descr);
    EXEC(2);
    }

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x1d5c4(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5080
movl %eax, 0x4(%rsp)
movq 0x1d5b1(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x1d97f(%rip), %rdx     # 0x243b0
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x5280
cmpl $0x6, %eax
je 0x6a66
movq 0x1d591(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
leaq 0x15803(%rip), %rsi     # 0x1c254
leaq 0x15816(%rip), %rdx     # 0x1c26e
movl $0x4a, %ecx
movb $0x0, %al
callq 0x5590
jmp 0x6ad9
jmp 0x6a68
movq 0x1d569(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movslq 0x14(%rsp), %rsi
callq 0x5300
movq 0x1d555(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x5670
movq 0x1d541(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
movq %r9, %r8
callq 0x5710
cmpl $0x0, %eax
je 0x6ac6
movq 0x1d51c(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
callq 0x5560
jmp 0x6ad9
movq 0x1d50b(%rip), %rax     # 0x23fd8
movq (%rax), %rdi
movl 0x4(%rsp), %esi
callq 0x50d0
addq $0x18, %rsp
retq
nop