LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/token.c
// Function: insert_token_order
int insert_token_order(char *line, char *token, FILE *fp)
{
//    TOKEN_ORDER *new_token_order;

    if(!strcmp(token,"//")){
        // //のコメント行は行末までコメントなので読み飛ばす
        do{
            get_line(line, fp);
            get_token(line, token);
        }while(strcmp(token,"\n"));
    }else if(!strcmp(token,"/*")){
        // /*のコメント行は*/までコメントなので読み飛ばす
        do{
            get_line(line, fp);
            get_token(line, token);
        }while(strcmp(token,"*/"));
        // 改行の場合は何もしない
    }else if(!strcmp(token,"\r")){
        // 改行の場合は何もしない
    }else if(!strcmp(token,"")){
        // トークンに何もない場合は何も処理しない
    }else{
        // トークンオーダーの新規取得
        create_token_order();

        // トークンオーダーにトークンを登録する
        token_order_current->str = (char *)malloc(strlen(token)+1);
        strcpy(token_order_current->str, token);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x396d(%rip), %rsi      # 0x1521c
callq 0x10d0
cmpl $0x0, %eax
jne 0x118ef
jmp 0x118bb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10e60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10eb0
movq -0x10(%rbp), %rdi
leaq 0x36e0(%rip), %rsi      # 0x14fc0
callq 0x10d0
cmpl $0x0, %eax
jne 0x118bb
jmp 0x119a7
movq -0x10(%rbp), %rdi
leaq 0x3925(%rip), %rsi      # 0x1521f
callq 0x10d0
cmpl $0x0, %eax
jne 0x11937
jmp 0x11906
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10e60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10eb0
movq -0x10(%rbp), %rdi
leaq 0x38f7(%rip), %rsi      # 0x15222
callq 0x10d0
cmpl $0x0, %eax
jne 0x11906
jmp 0x119a5
movq -0x10(%rbp), %rdi
leaq 0x189a(%rip), %rsi      # 0x131dc
callq 0x10d0
cmpl $0x0, %eax
jne 0x1194e
jmp 0x119a3
movq -0x10(%rbp), %rdi
leaq 0x3668(%rip), %rsi      # 0x14fc1
callq 0x10d0
cmpl $0x0, %eax
jne 0x11965
jmp 0x119a1
callq 0x119b0
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1100
movq %rax, %rcx
movq 0x6c47(%rip), %rax      # 0x185d0
movq %rcx, 0x10(%rax)
movq 0x6c3c(%rip), %rax      # 0x185d0
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
jmp 0x119a3
jmp 0x119a5
jmp 0x119a7
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/token.c
// Function: create_token_order
int create_token_order()
{
    // トークンオーダーの生成
    if(token_order_top == NULL){
        // 先頭トークンオーダーが空の場合、新規取得したトークンオーダーをセットする
        token_order_top = (TOKEN_ORDER *)malloc(sizeof(TOKEN_ORDER));
        token_order_current = token_order_top;
    }else{
        token_order_current->next_ptr = (TOKEN_ORDER *)malloc(sizeof(TOKEN_ORDER));
        token_order_prev    = token_order_current;
        token_order_current = token_order_prev->next_ptr;
    }
    token_order_current->next_ptr   = NULL;
    token_order_current->str        = NULL;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x6c0c(%rip)      # 0x185c8
jne 0x119df
movl $0x18, %edi
callq 0x1100
movq %rax, 0x6bf9(%rip)      # 0x185c8
movq 0x6bf2(%rip), %rax      # 0x185c8
movq %rax, 0x6bf3(%rip)      # 0x185d0
jmp 0x11a15
movl $0x18, %edi
callq 0x1100
movq %rax, %rcx
movq 0x6bdd(%rip), %rax      # 0x185d0
movq %rcx, (%rax)
movq 0x6bd3(%rip), %rax      # 0x185d0
movq %rax, 0x6bd4(%rip)      # 0x185d8
movq 0x6bcd(%rip), %rax      # 0x185d8
movq (%rax), %rax
movq %rax, 0x6bbb(%rip)      # 0x185d0
movq 0x6bb4(%rip), %rax      # 0x185d0
movq $0x0, (%rax)
movq 0x6ba6(%rip), %rax      # 0x185d0
movq $0x0, 0x10(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/token.c
// Function: clean_token_order
int clean_token_order()
{
    TOKEN_ORDER *new_token_order;

    token_order_current = token_order_top;
    while(1){
        if(token_order_current == NULL) break;
        new_token_order = token_order_current->next_ptr;
        free(token_order_current);
        token_order_current = new_token_order;
    }
    token_order_top = NULL;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x6b79(%rip), %rax      # 0x185c8
movq %rax, 0x6b7a(%rip)      # 0x185d0
cmpq $0x0, 0x6b72(%rip)      # 0x185d0
jne 0x11a62
jmp 0x11a89
movq 0x6b67(%rip), %rax      # 0x185d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x6b59(%rip), %rdi      # 0x185d0
callq 0x1030
movq -0x8(%rbp), %rax
movq %rax, 0x6b49(%rip)      # 0x185d0
jmp 0x11a56
movq $0x0, 0x6b34(%rip) # 0x185c8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/token.c
// Function: read_token
int read_token(char *token)
{
    if(token_order_current != NULL){
        strcpy(token, token_order_current->str);
        token_order_prev    = token_order_current;
        token_order_current = token_order_current->next_ptr;
        return 0;
    }else{
        *token = '\0';
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0x6b1c(%rip)      # 0x185d0
je 0x11af2
movq -0x10(%rbp), %rdi
movq 0x6b0f(%rip), %rax      # 0x185d0
movq 0x10(%rax), %rsi
callq 0x1050
movq 0x6aff(%rip), %rax      # 0x185d0
movq %rax, 0x6b00(%rip)      # 0x185d8
movq 0x6af1(%rip), %rax      # 0x185d0
movq (%rax), %rax
movq %rax, 0x6ae7(%rip)      # 0x185d0
movl $0x0, -0x4(%rbp)
jmp 0x11b00
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/token.c
// Function: read_file
int read_file(char *filename)
{
    FILE *fp;
    char *line, *token;

	line = malloc(STR_MAX);
	token = malloc(STR_MAX);

	memset(line, 0, STR_MAX);
	memset(token, 0, STR_MAX);

    printf("Open Filename: %s\n",filename);
    if((fp =fopen(filename,"rb")) == NULL){
        printf("can't open file.\n");
		free(line);
		free(token);
        exit(1);
    }
    while(1){
        get_line(line, fp);
        get_token(line, token);
        if(*token == '\0') break;
        insert_token_order(line, token, fp);    // トークンを追加する
    }
    fclose(fp);

	free(line);
	free(token);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, -0x18(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10a0
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10a0
movq -0x8(%rbp), %rsi
leaq 0x3632(%rip), %rdi      # 0x15225
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rdi
leaq 0x34bf(%rip), %rsi      # 0x150c4
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x11c3e
leaq 0x34ac(%rip), %rdi      # 0x150c7
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movl $0x1, %edi
callq 0x1170
jmp 0x11c40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10e60
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10eb0
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11c68
jmp 0x11c7b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x11890
jmp 0x11c40
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aquaxis[P]synverll/src/token.c
// Function: get_chara_llvm
int get_chara_llvm(char *line, char *token)
{
    char *p, *ptk, *pp;

    // ポインタの初期化
    p   = line;
    ptk = token;

    *ptk = 0;

    // cか"の場合、読み飛ばす
    while(*p == 'c' || *p == '"') ++p;
    // バッファが空の場合は終了する
    if(*p == '\0'){
		pp = malloc(strlen(p)+1);	// 残りの文字列をlineに戻す
		strcpy(pp,p);
		strcpy(line,pp);
		free(pp);
        token[0] = '\0';
        return 1;
    }

    if(*p == '"'){
		// "は終了
		*ptk = 0;
		return -1;
    }else if(*p == '\\'){
        (*p)++;
		// \はこの後に2文字16進数が続く
		/*
		 * ToDo:
		 *   isxdigit(*p)でエラー処理を入れる
		 */
        *ptk = *p++;
		*ptk <<= 4;	// 16倍する
        *ptk = *p++;
    }else{	// それ以外は一文字のキャラクターとして処理する
        *ptk = *p++;
	}
    pp = malloc(strlen(p)+1);	// 残りの文字列をlineに戻す
    strcpy(pp,p);
    strcpy(line,pp);
    free(pp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x63, %ecx
movb %al, -0x31(%rbp)
je 0x12828
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x12831
jmp 0x1283f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12807
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1289a
movq -0x20(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1050
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x12968
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x128b9
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12968
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x1290c
movq -0x20(%rbp), %rax
movb (%rax), %cl
addb $0x1, %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
shll $0x4, %ecx
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
jmp 0x12923
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
jmp 0x12925
movq -0x20(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1050
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisKeepAlive
int redisKeepAlive(redisContext *c, int interval) {
    int val = 1;
    int fd = c->fd;

    if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &val, sizeof(val)) == -1){
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = interval;

#ifdef _OSX
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }
#else
#if defined(__GLIBC__) && !defined(__FreeBSD_kernel__)
    val = interval;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = interval/3;
    if (val == 0) val = 1;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }

    val = 3;
    if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &val, sizeof(val)) < 0) {
        __redisSetError(c,REDIS_ERR_OTHER,strerror(errno));
        return REDIS_ERR;
    }
#endif
#endif

    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x30e0
cmpl $-0x1, %eax
jne 0x36f5
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x34e0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3815
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x6, %esi
movl $0x4, %r8d
leaq -0x18(%rbp), %rcx
movl %r8d, %edx
callq 0x30e0
cmpl $0x0, %eax
jge 0x3751
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x34e0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3815
movl -0x14(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x376c
movl $0x1, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x6, %esi
movl $0x5, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x30e0
cmpl $0x0, %eax
jge 0x37bb
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x34e0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3815
movl $0x3, -0x18(%rbp)
movl -0x1c(%rbp), %edi
movl $0x6, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
movl %edx, %esi
callq 0x30e0
cmpl $0x0, %eax
jge 0x380e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x34e0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3815
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisCheckSocketError
int redisCheckSocketError(redisContext *c) {
    int err = 0;
    socklen_t errlen = sizeof(err);

    if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"getsockopt(SO_ERROR)");
        return REDIS_ERR;
    }

    if (err) {
        errno = err;
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        return REDIS_ERR;
    }

    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x4, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x1, %esi
movl $0x4, %edx
leaq -0x14(%rbp), %rcx
leaq -0x18(%rbp), %r8
callq 0x3270
cmpl $-0x1, %eax
jne 0x387e
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x9790(%rip), %rdx      # 0xd000
callq 0x38c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38b6
cmpl $0x0, -0x14(%rbp)
je 0x38af
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x3070
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x38c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38b6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: _redisSetErrorFromErrno
static void __redisSetErrorFromErrno(redisContext *c, int type, const char *prefix) {
    char buf[128] = { 0 };
    size_t len = 0;

    if (prefix != NULL)
        len = snprintf(buf,sizeof(buf),"%s: ",prefix);
    __redis_strerror_r(errno, (char *)(buf + len), sizeof(buf) - len);
    __redisSetError(c,type,buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3200
movq $0x0, -0xa8(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3922
leaq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x80, %esi
leaq 0x9733(%rip), %rdx      # 0xd045
movb $0x0, %al
callq 0x3190
cltq
movq %rax, -0xa8(%rbp)
jmp 0x3924
callq 0x3070
movl (%rax), %edi
leaq -0xa0(%rbp), %rsi
addq -0xa8(%rbp), %rsi
movl $0x80, %edx
subq -0xa8(%rbp), %rdx
callq 0x3100
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0xa0(%rbp), %rdx
callq 0x32a0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisContextSetTimeout
int redisContextSetTimeout(redisContext *c, const struct timeval tv) {
    if (setsockopt(c->fd,SOL_SOCKET,SO_RCVTIMEO,&tv,sizeof(tv)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_RCVTIMEO)");
        return REDIS_ERR;
    }
    if (setsockopt(c->fd,SOL_SOCKET,SO_SNDTIMEO,&tv,sizeof(tv)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(SO_SNDTIMEO)");
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq -0x18(%rbp), %rcx
movl $0x10, %r8d
callq 0x30e0
cmpl $-0x1, %eax
jne 0x39ca
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x9659(%rip), %rdx      # 0xd015
callq 0x38c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a17
movq -0x20(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x1, %esi
movl $0x15, %edx
leaq -0x18(%rbp), %rcx
movl $0x10, %r8d
callq 0x30e0
cmpl $-0x1, %eax
jne 0x3a10
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x962b(%rip), %rdx      # 0xd02d
callq 0x38c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a17
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisCreateSocket
static int redisCreateSocket(redisContext *c, int type) {
    int s;
    if ((s = socket(type, SOCK_STREAM, 0)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        return REDIS_ERR;
    }
    c->fd = s;
    if (type == AF_INET) {
        if (redisSetReuseAddr(c) == REDIS_ERR) {
            return REDIS_ERR;
        }
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3550
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x42b1
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x38c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42e4
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x84(%rax)
cmpl $0x2, -0x14(%rbp)
jne 0x42dd
movq -0x10(%rbp), %rdi
callq 0x4640
cmpl $-0x1, %eax
jne 0x42db
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42e4
jmp 0x42dd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisSetBlocking
static int redisSetBlocking(redisContext *c, int blocking) {
    int flags;

    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(c->fd, F_GETFL)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
        redisContextCloseFd(c);
        return REDIS_ERR;
    }

    if (blocking)
        flags &= ~O_NONBLOCK;
    else
        flags |= O_NONBLOCK;

    if (fcntl(c->fd, F_SETFL, flags) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
        redisContextCloseFd(c);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x3110
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x4344
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x8d79(%rip), %rdx      # 0xd0a6
callq 0x38c0
movq -0x10(%rbp), %rdi
callq 0x4570
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43ae
cmpl $0x0, -0x14(%rbp)
je 0x4357
movl -0x18(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x18(%rbp)
jmp 0x4362
movl -0x18(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl -0x18(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x3110
cmpl $-0x1, %eax
jne 0x43a7
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x8d25(%rip), %rdx      # 0xd0b5
callq 0x38c0
movq -0x10(%rbp), %rdi
callq 0x4570
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x43ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisSetTcpNoDelay
static int redisSetTcpNoDelay(redisContext *c) {
    int yes = 1;
    if (setsockopt(c->fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"setsockopt(TCP_NODELAY)");
        redisContextCloseFd(c);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x30e0
cmpl $-0x1, %eax
jne 0x4622
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x8a83(%rip), %rdx      # 0xd08e
callq 0x38c0
movq -0x10(%rbp), %rdi
callq 0x4570
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4629
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/andyfighting[P]hiredis_timer_cmpt/net.c
// Function: redisSetReuseAddr
static int redisSetReuseAddr(redisContext *c) {
    int on = 1;
    if (setsockopt(c->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
        redisContextCloseFd(c);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x30e0
cmpl $-0x1, %eax
jne 0x469f
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x38c0
movq -0x10(%rbp), %rdi
callq 0x4570
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x46a6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: freeReplyObject
void freeReplyObject(void *reply) {
    redisReply *r = reply;
    size_t j;

    if (r == NULL)
        return;

    switch(r->type) {
    case REDIS_REPLY_INTEGER:
        break; /* Nothing to free */
    case REDIS_REPLY_ARRAY:
        if (r->element != NULL) {
            for (j = 0; j < r->elements; j++)
                if (r->element[j] != NULL)
                    freeReplyObject(r->element[j]);
            free(r->element);
        }
        break;
    case REDIS_REPLY_ERROR:
    case REDIS_REPLY_STATUS:
    case REDIS_REPLY_STRING:
        if (r->str != NULL)
            free(r->str);
        break;
    }
    free(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4710
jmp 0x47cb
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x47c2
movq -0x20(%rbp), %rax
leaq 0x899a(%rip), %rcx      # 0xd0cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x47c2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x47a6
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x4799
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4789
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x33f0
jmp 0x478b
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4753
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3040
jmp 0x47c2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x47c0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3040
jmp 0x47c2
movq -0x10(%rbp), %rdi
callq 0x3040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: countDigits
static uint32_t countDigits(uint64_t v) {
  uint32_t result = 1;
  for (;;) {
    if (v < 10) return result;
    if (v < 100) return result + 1;
    if (v < 1000) return result + 2;
    if (v < 10000) return result + 3;
    v /= 10000U;
    result += 4;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpq $0xa, -0x10(%rbp)
jae 0x546e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x54c7
cmpq $0x64, -0x10(%rbp)
jae 0x5480
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x54c7
cmpq $0x3e8, -0x10(%rbp)     # imm = 0x3E8
jae 0x5495
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x54c7
cmpq $0x2710, -0x10(%rbp)    # imm = 0x2710
jae 0x54aa
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0x54c7
movq -0x10(%rbp), %rax
movl $0x2710, %ecx           # imm = 0x2710
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
jmp 0x545f
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisFormatCommand
int redisFormatCommand(char **target, const char *format, ...) {
    va_list ap;
    int len;
    va_start(ap,format);
    len = redisvFormatCommand(target,format,ap);
    va_end(ap);

    /* The API says "-1" means bad result, but we now also return "-2" in some
     * cases.  Force the return value to always be -1. */
    if (len < 0)
        len = -1;

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x550b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x3500
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x34(%rbp)
jge 0x5578
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: _redisSetError
void __redisSetError(redisContext *c, int type, const char *str) {
    size_t len;

    c->err = type;
    if (str != NULL) {
        len = strlen(str);
        len = len < (sizeof(c->errstr)-1) ? len : (sizeof(c->errstr)-1);
        memcpy(c->errstr,str,len);
        c->errstr[len] = '\0';
    } else {
        /* Only REDIS_ERR_IO may lack a description! */
        assert(type == REDIS_ERR_IO);
        __redis_strerror_r(errno, c->errstr, sizeof(c->errstr));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x5a48
movq -0x18(%rbp), %rdi
callq 0x3140
movq %rax, -0x20(%rbp)
cmpq $0x7f, -0x20(%rbp)
jae 0x5a11
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5a1c
movl $0x7f, %eax
movq %rax, -0x28(%rbp)
jmp 0x5a1c
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x32f0
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, 0x4(%rax,%rcx)
jmp 0x5a8c
cmpl $0x1, -0xc(%rbp)
jne 0x5a50
jmp 0x5a6f
leaq 0x77c2(%rip), %rdi      # 0xd219
leaq 0x76b9(%rip), %rsi      # 0xd117
movl $0x247, %edx            # imm = 0x247
leaq 0x77c4(%rip), %rcx      # 0xd22e
callq 0x31c0
jmp 0x5a71
callq 0x3070
movl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x4, %rsi
movl $0x80, %edx
callq 0x3100
jmp 0x5a8c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisFree
void redisFree(redisContext *c) {
    if (c == NULL)
        return;
    if (c->fd > 0)
        close(c->fd);
    if (c->obuf != NULL)
        sdsfree(c->obuf);
    if (c->reader != NULL)
        redisReaderFree(c->reader);
    if (c->tcp.host)
        free(c->tcp.host);
    if (c->tcp.source_addr)
        free(c->tcp.source_addr);
    if (c->unix_sock.path)
        free(c->unix_sock.path);
    if (c->timeout)
        free(c->timeout);
    free(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5ad8
jmp 0x5bb1
movq -0x8(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jle 0x5af4
movq -0x8(%rbp), %rax
movl 0x84(%rax), %edi
callq 0x3210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x5b12
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x3280
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x5b30
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x34c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x5b4e
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x3040
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x5b6c
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rdi
callq 0x3040
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x5b8a
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x3040
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x5ba8
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x3040
movq -0x8(%rbp), %rdi
callq 0x3040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisFreeKeepFd
int redisFreeKeepFd(redisContext *c) {
    int fd = c->fd;
    c->fd = -1;
    redisFree(c);
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x84(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x3330
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisReconnect
int redisReconnect(redisContext *c) {
    c->err = 0;
    memset(c->errstr, '\0', strlen(c->errstr));

    if (c->fd > 0) {
        close(c->fd);
    }

    sdsfree(c->obuf);
    redisReaderFree(c->reader);

    c->obuf = sdsempty();
    c->reader = redisReaderCreate();

    if (c->connection_type == REDIS_CONN_TCP) {
        return redisContextConnectBindTcp(c, c->tcp.host, c->tcp.port,
                c->timeout, c->tcp.source_addr);
    } else if (c->connection_type == REDIS_CONN_UNIX) {
        return redisContextConnectUnix(c, c->unix_sock.path, c->timeout);
    } else {
        /* Something bad happened here and shouldn't have. There isn't
           enough information in the context to reconnect. */
        __redisSetError(c,REDIS_ERR_OTHER,"Not enough information to reconnect");
    }

    return REDIS_ERR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x3140
movq -0x18(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x3200
movq -0x10(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jle 0x5c59
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
callq 0x3210
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x34c0
callq 0x34a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
callq 0x3090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
jne 0x5ce5
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %edx
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %r8
callq 0x32d0
movl %eax, -0x4(%rbp)
jmp 0x5d34
movq -0x10(%rbp), %rax
cmpl $0x1, 0xa0(%rax)
jne 0x5d16
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rdx
callq 0x32b0
movl %eax, -0x4(%rbp)
jmp 0x5d34
movq -0x10(%rbp), %rdi
movl $0x2, %esi
leaq 0x7540(%rip), %rdx      # 0xd266
callq 0x32a0
jmp 0x5d2d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnect
redisContext *redisConnect(const char *ip, int port) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->flags |= REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x5db0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5d69
movq $0x0, -0x8(%rbp)
jmp 0x5d98
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3400
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisContextInit
static redisContext *redisContextInit(void) {
    redisContext *c;

    c = calloc(1,sizeof(redisContext));
    if (c == NULL)
        return NULL;

    c->err = 0;
    c->errstr[0] = '\0';
    c->obuf = sdsempty();
    c->reader = redisReaderCreate();
    c->tcp.host = NULL;
    c->tcp.source_addr = NULL;
    c->unix_sock.path = NULL;
    c->timeout = NULL;

    if (c->obuf == NULL || c->reader == NULL) {
        redisFree(c);
        return NULL;
    }

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0xd0, %esi
callq 0x3290
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5ddf
movq $0x0, -0x8(%rbp)
jmp 0x5e8a
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x4(%rax)
callq 0x34a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
callq 0x3090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x5e6f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x5e82
movq -0x10(%rbp), %rdi
callq 0x3330
movq $0x0, -0x8(%rbp)
jmp 0x5e8a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectWithTimeout
redisContext *redisConnectWithTimeout(const char *ip, int port, const struct timeval tv) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->flags |= REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,&tv);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
callq 0x5db0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5ed1
movq $0x0, -0x8(%rbp)
jmp 0x5f00
movq -0x30(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
leaq -0x18(%rbp), %rcx
callq 0x3400
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectNonBlock
redisContext *redisConnectNonBlock(const char *ip, int port) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->flags &= ~REDIS_BLOCK;
    redisContextConnectTcp(c,ip,port,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x5db0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5f39
movq $0x0, -0x8(%rbp)
jmp 0x5f68
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x88(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3400
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectBindNonBlock
redisContext *redisConnectBindNonBlock(const char *ip, int port,
                                       const char *source_addr) {
    redisContext *c = redisContextInit();
    c->flags &= ~REDIS_BLOCK;
    redisContextConnectBindTcp(c,ip,port,NULL,source_addr);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x5db0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x88(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x32d0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectBindNonBlockWithReuse
redisContext *redisConnectBindNonBlockWithReuse(const char *ip, int port,
                                                const char *source_addr) {
    redisContext *c = redisContextInit();
    c->flags &= ~REDIS_BLOCK;
    c->flags |= REDIS_REUSEADDR;
    redisContextConnectBindTcp(c,ip,port,NULL,source_addr);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x5db0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x88(%rax)
movq -0x20(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x88(%rax)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x32d0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectUnix
redisContext *redisConnectUnix(const char *path) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->flags |= REDIS_BLOCK;
    redisContextConnectUnix(c,path,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x5db0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6076
movq $0x0, -0x8(%rbp)
jmp 0x60a2
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x32b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectUnixWithTimeout
redisContext *redisConnectUnixWithTimeout(const char *path, const struct timeval tv) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->flags |= REDIS_BLOCK;
    redisContextConnectUnix(c,path,&tv);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
callq 0x5db0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x60de
movq $0x0, -0x8(%rbp)
jmp 0x610a
movq -0x28(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x32b0
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/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectUnixNonBlock
redisContext *redisConnectUnixNonBlock(const char *path) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->flags &= ~REDIS_BLOCK;
    redisContextConnectUnix(c,path,NULL);
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x5db0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6146
movq $0x0, -0x8(%rbp)
jmp 0x6172
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x88(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x32b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisConnectFd
redisContext *redisConnectFd(int fd) {
    redisContext *c;

    c = redisContextInit();
    if (c == NULL)
        return NULL;

    c->fd = fd;
    c->flags |= REDIS_BLOCK | REDIS_CONNECTED;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
callq 0x5db0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x61a5
movq $0x0, -0x8(%rbp)
jmp 0x61cd
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x84(%rax)
movq -0x18(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x3, %ecx
movl %ecx, 0x88(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisBufferRead
int redisBufferRead(redisContext *c) {
    char buf[1024*16];
    int nread;

    /* Return early when the context has seen an error. */
    if (c->err)
        return REDIS_ERR;

    nread = read(c->fd,buf,sizeof(buf));
    if (nread == -1) {
        if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
            /* Try again later */
        } else {
            __redisSetError(c,REDIS_ERR_IO,NULL);
            return REDIS_ERR;
        }
    } else if (nread == 0) {
        __redisSetError(c,REDIS_ERR_EOF,"Server closed the connection");
        return REDIS_ERR;
    } else {
        if (redisReaderFeed(c->reader,buf,nread) != REDIS_OK) {
            __redisSetError(c,c->reader->err,c->reader->errstr);
            return REDIS_ERR;
        }
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6294
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6389
movq -0x10(%rbp), %rax
movl 0x84(%rax), %edi
leaq -0x4010(%rbp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x3250
movl %eax, -0x4014(%rbp)
cmpl $-0x1, -0x4014(%rbp)
jne 0x6306
callq 0x3070
cmpl $0xb, (%rax)
jne 0x62da
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x62e4
callq 0x3070
cmpl $0x4, (%rax)
jne 0x62e6
jmp 0x6304
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6389
jmp 0x6382
cmpl $0x0, -0x4014(%rbp)
jne 0x632d
movq -0x10(%rbp), %rdi
movl $0x3, %esi
leaq 0x6f6b(%rip), %rdx      # 0xd28a
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6389
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
leaq -0x4010(%rbp), %rsi
movslq -0x4014(%rbp), %rdx
callq 0x31b0
cmpl $0x0, %eax
je 0x637e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
addq $0x4, %rdx
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6389
jmp 0x6380
jmp 0x6382
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisBufferWrite
int redisBufferWrite(redisContext *c, int *done) {
    int nwritten;

    /* Return early when the context has seen an error. */
    if (c->err)
        return REDIS_ERR;

    if (sdslen(c->obuf) > 0) {
        nwritten = write(c->fd,c->obuf,sdslen(c->obuf));
        if (nwritten == -1) {
            if ((errno == EAGAIN && !(c->flags & REDIS_BLOCK)) || (errno == EINTR)) {
                /* Try again later */
            } else {
                __redisSetError(c,REDIS_ERR_IO,NULL);
                return REDIS_ERR;
            }
        } else if (nwritten > 0) {
            if (nwritten == (signed)sdslen(c->obuf)) {
                sdsfree(c->obuf);
                c->obuf = sdsempty();
            } else {
                sdsrange(c->obuf,nwritten,-1);
            }
        }
    }
    if (done != NULL) *done = (sdslen(c->obuf) == 0);
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x63c5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6504
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x46b0
cmpq $0x0, %rax
jbe 0x64d4
movq -0x10(%rbp), %rax
movl 0x84(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x46b0
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x3130
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x646b
callq 0x3070
cmpl $0xb, (%rax)
jne 0x643f
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6449
callq 0x3070
cmpl $0x4, (%rax)
jne 0x644b
jmp 0x6469
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6504
jmp 0x64d2
cmpl $0x0, -0x1c(%rbp)
jle 0x64d0
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x46b0
movq %rax, %rcx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x64b6
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x3280
callq 0x34a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0x64ce
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
movl -0x1c(%rbp), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x3230
jmp 0x64d0
jmp 0x64d2
jmp 0x64d4
cmpq $0x0, -0x18(%rbp)
je 0x64fd
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x46b0
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/andyfighting[P]hiredis_timer_cmpt/hiredis.c
// Function: redisGetReplyFromReader
int redisGetReplyFromReader(redisContext *c, void **reply) {
    if (redisReaderGetReply(c->reader,reply) == REDIS_ERR) {
        __redisSetError(c,c->reader->err,c->reader->errstr);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x30f0
cmpl $-0x1, %eax
jne 0x6567
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdx
addq $0x4, %rdx
callq 0x32a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x656e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)