LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/server.c
// Function: redisSetProcTitle
void redisSetProcTitle(char *title) {
#ifdef USE_SETPROCTITLE
    char *server_mode = "";
    if (server.cluster_enabled) server_mode = " [cluster]";
    else if (server.sentinel_mode) server_mode = " [sentinel]";

    setproctitle("%s %s:%d%s",
        title,
        server.bindaddr_count ? server.bindaddr[0] : "*",
        server.port,
        server_mode);
#else
    UNUSED(title);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x103dbf(%rip), %rax    # 0x13b612
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x141316(%rip)    # 0x178b74
je 0x3786d
leaq 0x1026f4(%rip), %rax    # 0x139f5b
movq %rax, -0x10(%rbp)
jmp 0x37883
cmpl $0x0, 0x140a00(%rip)    # 0x178274
je 0x37881
leaq 0x1026e9(%rip), %rax    # 0x139f66
movq %rax, -0x10(%rbp)
jmp 0x37883
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x140a6e(%rip)    # 0x178300
je 0x378a1
movq 0x1409e5(%rip), %rax    # 0x178280
movq %rax, -0x20(%rbp)
jmp 0x378ae
leaq 0x1002c3(%rip), %rax    # 0x137b6b
movq %rax, -0x20(%rbp)
jmp 0x378ae
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl 0x1409bc(%rip), %ecx    # 0x178278
movq -0x10(%rbp), %r8
leaq 0x1026ab(%rip), %rdi    # 0x139f72
movb $0x0, %al
callq 0x9d410
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/server.c
// Function: redisSupervisedUpstart
int redisSupervisedUpstart(void) {
    const char *upstart_job = getenv("UPSTART_JOB");

    if (!upstart_job) {
        serverLog(LL_WARNING,
                "upstart supervision requested, but UPSTART_JOB not found");
        return 0;
    }

    serverLog(LL_NOTICE, "supervised by upstart, will stop to signal readiness");
    raise(SIGSTOP);
    unsetenv("UPSTART_JOB");
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10268e(%rip), %rdi    # 0x139f7d
callq 0x26850
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3791b
movl $0x3, %edi
leaq 0x10267e(%rip), %rsi    # 0x139f89
movb $0x0, %al
callq 0x2fc60
movl $0x0, -0x4(%rbp)
jmp 0x3794b
movl $0x2, %edi
leaq 0x10269b(%rip), %rsi    # 0x139fc2
movb $0x0, %al
callq 0x2fc60
movl $0x13, %edi
callq 0x267b0
leaq 0x10263e(%rip), %rdi    # 0x139f7d
callq 0x26a80
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/server.c
// Function: redisIsSupervised
int redisIsSupervised(int mode) {
    if (mode == SUPERVISED_AUTODETECT) {
        const char *upstart_job = getenv("UPSTART_JOB");
        const char *notify_socket = getenv("NOTIFY_SOCKET");

        if (upstart_job) {
            redisSupervisedUpstart();
        } else if (notify_socket) {
            redisSupervisedSystemd();
        }
    } else if (mode == SUPERVISED_UPSTART) {
        return redisSupervisedUpstart();
    } else if (mode == SUPERVISED_SYSTEMD) {
        return redisSupervisedSystemd();
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x37bbf
leaq 0x1023f5(%rip), %rdi    # 0x139f7d
callq 0x26850
movq %rax, -0x10(%rbp)
leaq 0x10245f(%rip), %rdi    # 0x139ff7
callq 0x26850
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37baf
callq 0x378e0
jmp 0x37bbd
cmpq $0x0, -0x18(%rbp)
je 0x37bbb
callq 0x37960
jmp 0x37bbd
jmp 0x37be3
cmpl $0x3, -0x8(%rbp)
jne 0x37bcf
callq 0x378e0
movl %eax, -0x4(%rbp)
jmp 0x37bea
cmpl $0x2, -0x8(%rbp)
jne 0x37bdf
callq 0x37960
movl %eax, -0x4(%rbp)
jmp 0x37bea
jmp 0x37be1
jmp 0x37be3
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/gplessis[P]dotdeb-redis/src/sds.c
// Function: sdsReqType
static inline char sdsReqType(size_t string_size) {
    if (string_size < 1<<5)
        return SDS_TYPE_5;
    if (string_size < 1<<8)
        return SDS_TYPE_8;
    if (string_size < 1<<16)
        return SDS_TYPE_16;
    if (string_size < 1ll<<32)
        return SDS_TYPE_32;
    return SDS_TYPE_64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jae 0x38435
movb $0x0, -0x1(%rbp)
jmp 0x3846f
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jae 0x38445
movb $0x1, -0x1(%rbp)
jmp 0x3846f
cmpq $0x10000, -0x10(%rbp)   # imm = 0x10000
jae 0x38455
movb $0x2, -0x1(%rbp)
jmp 0x3846f
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x10(%rbp)
jae 0x3846b
movb $0x3, -0x1(%rbp)
jmp 0x3846f
movb $0x4, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapNew
unsigned char *zipmapNew(void) {
    unsigned char *zm = zmalloc(2);

    zm[0] = 0; /* Length */
    zm[1] = ZIPMAP_END;
    return zm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %edi
callq 0x3acd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x1(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapRequiredLength
static unsigned long zipmapRequiredLength(unsigned int klen, unsigned int vlen) {
    unsigned int l;

    l = klen+vlen+3;
    if (klen >= ZIPMAP_BIGLEN) l += 4;
    if (vlen >= ZIPMAP_BIGLEN) l += 4;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xc(%rbp)
cmpl $0xfe, -0x4(%rbp)
jb 0x3d4c8
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
cmpl $0xfe, -0x8(%rbp)
jb 0x3d4da
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapLookupRaw
static unsigned char *zipmapLookupRaw(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned int *totlen) {
    unsigned char *p = zm+1, *k = NULL;
    unsigned int l,llen;

    while(*p != ZIPMAP_END) {
        unsigned char free;

        /* Match or skip the key */
        l = zipmapDecodeLength(p);
        llen = zipmapEncodeLength(NULL,l);
        if (key != NULL && k == NULL && l == klen && !memcmp(p+llen,key,l)) {
            /* Only return when the user doesn't care
             * for the total length of the zipmap. */
            if (totlen != NULL) {
                k = p;
            } else {
                return p;
            }
        }
        p += llen+l;
        /* Skip the value as well */
        l = zipmapDecodeLength(p);
        p += zipmapEncodeLength(NULL,l);
        free = p[0];
        p += l+1+free; /* +1 to skip the free byte */
    }
    if (totlen != NULL) *totlen = (unsigned int)(p-zm)+1;
    return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x3d5ec
movq -0x30(%rbp), %rdi
callq 0x3d910
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x3d6a0
movl %eax, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3d58b
cmpq $0x0, -0x38(%rbp)
jne 0x3d58b
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x3d58b
movq -0x30(%rbp), %rdi
movl -0x40(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x3c(%rbp), %eax
movl %eax, %edx
callq 0x269b0
cmpl $0x0, %eax
jne 0x3d58b
cmpq $0x0, -0x28(%rbp)
je 0x3d57c
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3d589
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3d611
jmp 0x3d58b
movl -0x40(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3d910
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x3d6a0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x41(%rbp)
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movzbl -0x41(%rbp), %eax
addl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x3d50b
cmpq $0x0, -0x28(%rbp)
je 0x3d609
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
addl $0x1, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapEncodeLength
static unsigned int zipmapEncodeLength(unsigned char *p, unsigned int len) {
    if (p == NULL) {
        return ZIPMAP_LEN_BYTES(len);
    } else {
        if (len < ZIPMAP_BIGLEN) {
            p[0] = len;
            return 1;
        } else {
            p[0] = ZIPMAP_BIGLEN;
            memcpy(p+1,&len,sizeof(len));
            memrev32ifbe(p+1);
            return 1+sizeof(len);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3d6ce
movl -0x14(%rbp), %edx
movl $0x5, %eax
movl $0x1, %ecx
cmpl $0xfe, %edx
cmovbq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x3d703
cmpl $0xfe, -0x14(%rbp)
jae 0x3d6eb
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3d703
movq -0x10(%rbp), %rax
movb $-0x2, (%rax)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x1(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapDel
unsigned char *zipmapDel(unsigned char *zm, unsigned char *key, unsigned int klen, int *deleted) {
    unsigned int zmlen, freelen;
    unsigned char *p = zipmapLookupRaw(zm,key,klen,&zmlen);
    if (p) {
        freelen = zipmapRawEntryLength(p);
        memmove(p, p+freelen, zmlen-((p-zm)+freelen+1));
        zm = zipmapResize(zm, zmlen-freelen);

        /* Decrease zipmap length */
        if (zm[0] < ZIPMAP_BIGLEN) zm[0]--;

        if (deleted) *deleted = 1;
    } else {
        if (deleted) *deleted = 0;
    }
    return zm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x24(%rbp), %rcx
callq 0x3d4e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3d7c1
movq -0x30(%rbp), %rdi
callq 0x3d660
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %eax
addq %rax, %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl -0x28(%rbp), %ecx
addq %rcx, %rax
addq $0x1, %rax
subq %rax, %rdx
callq 0x267e0
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
subl -0x28(%rbp), %esi
callq 0x3d620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0x3d7ae
movq -0x8(%rbp), %rax
movb (%rax), %cl
addb $-0x1, %cl
movb %cl, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x3d7bf
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
jmp 0x3d7d4
cmpq $0x0, -0x20(%rbp)
je 0x3d7d2
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
jmp 0x3d7d4
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapNext
unsigned char *zipmapNext(unsigned char *zm, unsigned char **key, unsigned int *klen, unsigned char **value, unsigned int *vlen) {
    if (zm[0] == ZIPMAP_END) return NULL;
    if (key) {
        *key = zm;
        *klen = zipmapDecodeLength(zm);
        *key += ZIPMAP_LEN_BYTES(*klen);
    }
    zm += zipmapRawKeyLength(zm);
    if (value) {
        *value = zm+1;
        *vlen = zipmapDecodeLength(zm);
        *value += ZIPMAP_LEN_BYTES(*vlen);
    }
    zm += zipmapRawValueLength(zm);
    return zm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x3d837
movq $0x0, -0x8(%rbp)
jmp 0x3d901
cmpq $0x0, -0x18(%rbp)
je 0x3d87e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3d910
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %edx
movl $0x5, %ecx
movl $0x1, %eax
cmpl $0xfe, %edx
cmovbq %rax, %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3d950
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3d8e1
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3d910
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %edx
movl $0x5, %ecx
movl $0x1, %eax
cmpl $0xfe, %edx
cmovbq %rax, %rcx
movq -0x28(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3d980
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapDecodeLength
static unsigned int zipmapDecodeLength(unsigned char *p) {
    unsigned int len = *p;

    if (len < ZIPMAP_BIGLEN) return len;
    memcpy(&len,p+1,sizeof(unsigned int));
    memrev32ifbe(&len);
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0xfe, -0x14(%rbp)
jae 0x3d933
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d943
movq -0x10(%rbp), %rax
movl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapRawValueLength
static unsigned int zipmapRawValueLength(unsigned char *p) {
    unsigned int l = zipmapDecodeLength(p);
    unsigned int used;

    used = zipmapEncodeLength(NULL,l);
    used += p[used] + 1 + l;
    return used;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3d910
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x3d6a0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
addl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapGet
int zipmapGet(unsigned char *zm, unsigned char *key, unsigned int klen, unsigned char **value, unsigned int *vlen) {
    unsigned char *p;

    if ((p = zipmapLookupRaw(zm,key,klen,NULL)) == NULL) return 0;
    p += zipmapRawKeyLength(p);
    *vlen = zipmapDecodeLength(p);
    *value = p + ZIPMAP_LEN_BYTES(*vlen) + 1;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3d4e0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x3da12
movl $0x0, -0x4(%rbp)
jmp 0x3da6e
movq -0x38(%rbp), %rdi
callq 0x3d950
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3d910
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movl (%rax), %esi
movl $0x5, %eax
movl $0x1, %edx
cmpl $0xfe, %esi
cmovbq %rdx, %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/zipmap.c
// Function: zipmapLen
unsigned int zipmapLen(unsigned char *zm) {
    unsigned int len = 0;
    if (zm[0] < ZIPMAP_BIGLEN) {
        len = zm[0];
    } else {
        unsigned char *p = zipmapRewind(zm);
        while((p = zipmapNext(p,NULL,NULL,NULL,NULL)) != NULL) len++;

        /* Re-store length if small enough */
        if (len < ZIPMAP_BIGLEN) zm[0] = len;
    }
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0x3daed
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x3db3c
movq -0x8(%rbp), %rdi
callq 0x3d7e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %r8, %rcx
callq 0x3d800
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3db26
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3dafa
cmpl $0xfe, -0xc(%rbp)
jae 0x3db3a
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
jmp 0x3db3c
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sha1.c
// Function: SHA1Init
void SHA1Init(SHA1_CTX* context)
{
    /* SHA1 initialization constants */
    context->state[0] = 0x67452301;
    context->state[1] = 0xEFCDAB89;
    context->state[2] = 0x98BADCFE;
    context->state[3] = 0x10325476;
    context->state[4] = 0xC3D2E1F0;
    context->count[0] = context->count[1] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sha1.c
// Function: SHA1Update
void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len)
{
    uint32_t i, j;

    j = context->count[0];
    if ((context->count[0] += len << 3) < j)
        context->count[1]++;
    context->count[1] += (len>>29);
    j = (j >> 3) & 63;
    if ((j + len) > 63) {
        memcpy(&context->buffer[j], data, (i = 64-j));
        SHA1Transform(context->state, context->buffer);
        for ( ; i + 63 < len; i += 64) {
            SHA1Transform(context->state, &data[i]);
        }
        j = 0;
    }
    else i = 0;
    memcpy(&context->buffer[j], &data[i], len - i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shll $0x3, %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
movl %eax, 0x14(%rcx)
cmpl -0x1c(%rbp), %eax
jae 0x3fa6f
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0x14(%rbp), %ecx
shrl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movl -0x1c(%rbp), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl -0x14(%rbp), %eax
cmpl $0x3f, %eax
jbe 0x3faff
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl %eax, %eax
movl %eax, %edx
callq 0x26c60
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1c, %rsi
callq 0x3db80
movl -0x18(%rbp), %eax
addl $0x3f, %eax
cmpl -0x14(%rbp), %eax
jae 0x3faf6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
callq 0x3db80
movl -0x18(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x18(%rbp)
jmp 0x3facd
movl $0x0, -0x1c(%rbp)
jmp 0x3fb06
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1c, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x26c60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/sha1.c
// Function: SHA1Final
void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
{
    unsigned i;
    unsigned char finalcount[8];
    unsigned char c;

#if 0	/* untested "improvement" by DHR */
    /* Convert context->count to a sequence of bytes
     * in finalcount.  Second element first, but
     * big-endian order within element.
     * But we do it all backwards.
     */
    unsigned char *fcp = &finalcount[8];

    for (i = 0; i < 2; i++)
       {
        uint32_t t = context->count[i];
        int j;

        for (j = 0; j < 4; t >>= 8, j++)
	          *--fcp = (unsigned char) t;
    }
#else
    for (i = 0; i < 8; i++) {
        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
    }
#endif
    c = 0200;
    SHA1Update(context, &c, 1);
    while ((context->count[0] & 504) != 448) {
	c = 0000;
        SHA1Update(context, &c, 1);
    }
    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
    for (i = 0; i < 20; i++) {
        digest[i] = (unsigned char)
         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
    }
    /* Wipe variables */
    memset(context, '\0', sizeof(*context));
    memset(&finalcount, '\0', sizeof(finalcount));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jae 0x3fba3
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %esi
movl $0x1, %ecx
xorl %edx, %edx
cmpl $0x4, %esi
cmovael %edx, %ecx
movslq %ecx, %rcx
movl 0x14(%rax,%rcx,4), %eax
movl -0x14(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %cl
movl -0x14(%rbp), %eax
movb %cl, -0x1c(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3fb57
movb $-0x80, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x3fa30
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x1f8, %eax            # imm = 0x1F8
cmpl $0x1c0, %eax            # imm = 0x1C0
je 0x3fbe4
movb $0x0, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x3fa30
jmp 0x3fbb9
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x8, %edx
callq 0x3fa30
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jae 0x3fc40
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ecx
shrl %cl, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3fbfd
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x5c, %edx
callq 0x26110
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x26110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipIntSize
unsigned int zipIntSize(unsigned char encoding) {
    switch(encoding) {
    case ZIP_INT_8B:  return 1;
    case ZIP_INT_16B: return 2;
    case ZIP_INT_24B: return 3;
    case ZIP_INT_32B: return 4;
    case ZIP_INT_64B: return 8;
    default: return 0; /* 4 bit immediate */
    }
    assert(NULL);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0xc0, %eax
je 0x3fcc3
jmp 0x3fc8a
movl -0xc(%rbp), %eax
subl $0xd0, %eax
je 0x3fcd5
jmp 0x3fc96
movl -0xc(%rbp), %eax
subl $0xe0, %eax
je 0x3fcde
jmp 0x3fca2
movl -0xc(%rbp), %eax
subl $0xf0, %eax
je 0x3fccc
jmp 0x3fcae
movl -0xc(%rbp), %eax
subl $0xfe, %eax
jne 0x3fce7
jmp 0x3fcba
movl $0x1, -0x4(%rbp)
jmp 0x3fcee
movl $0x2, -0x4(%rbp)
jmp 0x3fcee
movl $0x3, -0x4(%rbp)
jmp 0x3fcee
movl $0x4, -0x4(%rbp)
jmp 0x3fcee
movl $0x8, -0x4(%rbp)
jmp 0x3fcee
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipEncodeLength
unsigned int zipEncodeLength(unsigned char *p, unsigned char encoding, unsigned int rawlen) {
    unsigned char len = 1, buf[5];

    if (ZIP_IS_STR(encoding)) {
        /* Although encoding is given it may not be set for strings,
         * so we determine it here using the raw length. */
        if (rawlen <= 0x3f) {
            if (!p) return len;
            buf[0] = ZIP_STR_06B | rawlen;
        } else if (rawlen <= 0x3fff) {
            len += 1;
            if (!p) return len;
            buf[0] = ZIP_STR_14B | ((rawlen >> 8) & 0x3f);
            buf[1] = rawlen & 0xff;
        } else {
            len += 4;
            if (!p) return len;
            buf[0] = ZIP_STR_32B;
            buf[1] = (rawlen >> 24) & 0xff;
            buf[2] = (rawlen >> 16) & 0xff;
            buf[3] = (rawlen >> 8) & 0xff;
            buf[4] = rawlen & 0xff;
        }
    } else {
        /* Implies integer encoding, so length is always 1. */
        if (!p) return len;
        buf[0] = encoding;
    }

    /* Store this length at p */
    memcpy(p,buf,len);
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movzbl -0x11(%rbp), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jge 0x3fded
cmpl $0x3f, -0x18(%rbp)
ja 0x3fd54
cmpq $0x0, -0x10(%rbp)
jne 0x3fd46
movzbl -0x19(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3fe1d
movl -0x18(%rbp), %eax
orl $0x0, %eax
movb %al, -0x1e(%rbp)
jmp 0x3fdeb
cmpl $0x3fff, -0x18(%rbp)    # imm = 0x3FFF
ja 0x3fd96
movzbl -0x19(%rbp), %eax
addl $0x1, %eax
movb %al, -0x19(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3fd7a
movzbl -0x19(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3fe1d
movl -0x18(%rbp), %eax
shrl $0x8, %eax
andl $0x3f, %eax
orl $0x40, %eax
movb %al, -0x1e(%rbp)
movl -0x18(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1d(%rbp)
jmp 0x3fde9
movzbl -0x19(%rbp), %eax
addl $0x4, %eax
movb %al, -0x19(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3fdb0
movzbl -0x19(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3fe1d
movb $-0x80, -0x1e(%rbp)
movl -0x18(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x1d(%rbp)
movl -0x18(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x1c(%rbp)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x1b(%rbp)
movl -0x18(%rbp), %eax
andl $0xff, %eax
movb %al, -0x1a(%rbp)
jmp 0x3fdeb
jmp 0x3fe03
cmpq $0x0, -0x10(%rbp)
jne 0x3fdfd
movzbl -0x19(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3fe1d
movb -0x11(%rbp), %al
movb %al, -0x1e(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
movzbl -0x19(%rbp), %eax
movl %eax, %edx
callq 0x26c60
movzbl -0x19(%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/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipPrevEncodeLength
unsigned int zipPrevEncodeLength(unsigned char *p, unsigned int len) {
    if (p == NULL) {
        return (len < ZIP_BIGLEN) ? 1 : sizeof(len)+1;
    } else {
        if (len < ZIP_BIGLEN) {
            p[0] = len;
            return 1;
        } else {
            p[0] = ZIP_BIGLEN;
            memcpy(p+1,&len,sizeof(len));
            memrev32ifbe(p+1);
            return 1+sizeof(len);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3fe5e
movl -0x14(%rbp), %edx
movl $0x5, %eax
movl $0x1, %ecx
cmpl $0xfe, %edx
cmovbq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0x3fe93
cmpl $0xfe, -0x14(%rbp)
jae 0x3fe7b
movl -0x14(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3fe93
movq -0x10(%rbp), %rax
movb $-0x2, (%rax)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x1(%rax)
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipPrevEncodeLengthForceLarge
void zipPrevEncodeLengthForceLarge(unsigned char *p, unsigned int len) {
    if (p == NULL) return;
    p[0] = ZIP_BIGLEN;
    memcpy(p+1,&len,sizeof(len));
    memrev32ifbe(p+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3feb4
jmp 0x3fec5
movq -0x8(%rbp), %rax
movb $-0x2, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x1(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipRawEntryLength
unsigned int zipRawEntryLength(unsigned char *p) {
    unsigned int prevlensize, encoding, lensize, len;
    ZIP_DECODE_PREVLENSIZE(p, prevlensize);
    ZIP_DECODE_LENGTH(p + prevlensize, encoding, lensize, len);
    return prevlensize + lensize + len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0x3ff43
movl $0x1, -0xc(%rbp)
jmp 0x3ff4a
movl $0x5, -0xc(%rbp)
jmp 0x3ff4c
jmp 0x3ff4e
jmp 0x3ff50
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rbp)
cmpl $0xc0, -0x10(%rbp)
jae 0x3ff72
movl -0x10(%rbp), %eax
andl $0xc0, %eax
movl %eax, -0x10(%rbp)
jmp 0x3ff74
cmpl $0xc0, -0x10(%rbp)
jae 0x40060
cmpl $0x0, -0x10(%rbp)
jne 0x3ffa4
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzbl (%rax,%rcx), %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
jmp 0x4005e
cmpl $0x40, -0x10(%rbp)
jne 0x3ffd8
movl $0x2, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzbl (%rax,%rcx), %eax
andl $0x3f, %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movzbl 0x1(%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x4005c
cmpl $0x80, -0x10(%rbp)
jne 0x4002c
movl $0x5, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzbl 0x1(%rax,%rcx), %eax
shll $0x18, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movzbl 0x2(%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movzbl 0x3(%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
movzbl 0x4(%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x4005a
xorl %eax, %eax
testb $0x1, %al
jne 0x40034
jmp 0x40036
jmp 0x40058
leaq 0xfdce2(%rip), %rdi     # 0x13dd1f
leaq 0xfa8a4(%rip), %rsi     # 0x13a8e8
movl $0x142, %edx            # imm = 0x142
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x4005a
jmp 0x4005c
jmp 0x4005e
jmp 0x40075
movl $0x1, -0x14(%rbp)
movl -0x10(%rbp), %eax
movzbl %al, %edi
callq 0x3fc70
movl %eax, -0x18(%rbp)
jmp 0x40077
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipTryEncoding
int zipTryEncoding(unsigned char *entry, unsigned int entrylen, long long *v, unsigned char *encoding) {
    long long value;

    if (entrylen >= 32 || entrylen == 0) return 0;
    if (string2ll((char*)entry,entrylen,&value)) {
        /* Great, the string can be encoded. Check what's the smallest
         * of our encoding types that can hold this value. */
        if (value >= 0 && value <= 12) {
            *encoding = ZIP_INT_IMM_MIN+value;
        } else if (value >= INT8_MIN && value <= INT8_MAX) {
            *encoding = ZIP_INT_8B;
        } else if (value >= INT16_MIN && value <= INT16_MAX) {
            *encoding = ZIP_INT_16B;
        } else if (value >= INT24_MIN && value <= INT24_MAX) {
            *encoding = ZIP_INT_24B;
        } else if (value >= INT32_MIN && value <= INT32_MAX) {
            *encoding = ZIP_INT_32B;
        } else {
            *encoding = ZIP_INT_64B;
        }
        *v = value;
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x20, -0x14(%rbp)
jae 0x400b3
cmpl $0x0, -0x14(%rbp)
jne 0x400bf
movl $0x0, -0x4(%rbp)
jmp 0x40194
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdx
callq 0x47970
cmpl $0x0, %eax
je 0x4018d
cmpq $0x0, -0x30(%rbp)
jl 0x400fc
cmpq $0xc, -0x30(%rbp)
jg 0x400fc
movq -0x30(%rbp), %rax
addq $0xf1, %rax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
jmp 0x40179
cmpq $-0x80, -0x30(%rbp)
jl 0x40113
cmpq $0x7f, -0x30(%rbp)
jg 0x40113
movq -0x28(%rbp), %rax
movb $-0x2, (%rax)
jmp 0x40177
cmpq $-0x8000, -0x30(%rbp)   # imm = 0x8000
jl 0x40130
cmpq $0x7fff, -0x30(%rbp)    # imm = 0x7FFF
jg 0x40130
movq -0x28(%rbp), %rax
movb $-0x40, (%rax)
jmp 0x40175
cmpq $-0x800000, -0x30(%rbp) # imm = 0xFF800000
jl 0x4014d
cmpq $0x7fffff, -0x30(%rbp)  # imm = 0x7FFFFF
jg 0x4014d
movq -0x28(%rbp), %rax
movb $-0x10, (%rax)
jmp 0x40173
cmpq $-0x80000000, -0x30(%rbp) # imm = 0x80000000
jl 0x4016a
cmpq $0x7fffffff, -0x30(%rbp) # imm = 0x7FFFFFFF
jg 0x4016a
movq -0x28(%rbp), %rax
movb $-0x30, (%rax)
jmp 0x40171
movq -0x28(%rbp), %rax
movb $-0x20, (%rax)
jmp 0x40173
jmp 0x40175
jmp 0x40177
jmp 0x40179
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x40194
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipSaveInteger
void zipSaveInteger(unsigned char *p, int64_t value, unsigned char encoding) {
    int16_t i16;
    int32_t i32;
    int64_t i64;
    if (encoding == ZIP_INT_8B) {
        ((int8_t*)p)[0] = (int8_t)value;
    } else if (encoding == ZIP_INT_16B) {
        i16 = value;
        memcpy(p,&i16,sizeof(i16));
        memrev16ifbe(p);
    } else if (encoding == ZIP_INT_24B) {
        i32 = value<<8;
        memrev32ifbe(&i32);
        memcpy(p,((uint8_t*)&i32)+1,sizeof(i32)-sizeof(uint8_t));
    } else if (encoding == ZIP_INT_32B) {
        i32 = value;
        memcpy(p,&i32,sizeof(i32));
        memrev32ifbe(p);
    } else if (encoding == ZIP_INT_64B) {
        i64 = value;
        memcpy(p,&i64,sizeof(i64));
        memrev64ifbe(p);
    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
        /* Nothing to do, the value is stored in the encoding itself. */
    } else {
        assert(NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0xfe, %eax
jne 0x401d1
movq -0x10(%rbp), %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
jmp 0x402ad
movzbl -0x11(%rbp), %eax
cmpl $0xc0, %eax
jne 0x401f4
movq -0x10(%rbp), %rax
movw %ax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movw -0x14(%rbp), %cx
movw %cx, (%rax)
jmp 0x402ab
movzbl -0x11(%rbp), %eax
cmpl $0xf0, %eax
jne 0x40220
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movw -0x17(%rbp), %cx
movw %cx, (%rax)
movb -0x15(%rbp), %cl
movb %cl, 0x2(%rax)
jmp 0x402a9
movzbl -0x11(%rbp), %eax
cmpl $0xd0, %eax
jne 0x4023d
movq -0x10(%rbp), %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x402a7
movzbl -0x11(%rbp), %eax
cmpl $0xe0, %eax
jne 0x4025d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x402a5
movzbl -0x11(%rbp), %eax
cmpl $0xf1, %eax
jl 0x40275
movzbl -0x11(%rbp), %eax
cmpl $0xfd, %eax
jg 0x40275
jmp 0x402a3
xorl %eax, %eax
testb $0x1, %al
jne 0x4027d
jmp 0x4027f
jmp 0x402a1
leaq 0xfda99(%rip), %rdi     # 0x13dd1f
leaq 0xfa65b(%rip), %rsi     # 0x13a8e8
movl $0x17c, %edx            # imm = 0x17C
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x402a3
jmp 0x402a5
jmp 0x402a7
jmp 0x402a9
jmp 0x402ab
jmp 0x402ad
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: zipLoadInteger
int64_t zipLoadInteger(unsigned char *p, unsigned char encoding) {
    int16_t i16;
    int32_t i32;
    int64_t i64, ret = 0;
    if (encoding == ZIP_INT_8B) {
        ret = ((int8_t*)p)[0];
    } else if (encoding == ZIP_INT_16B) {
        memcpy(&i16,p,sizeof(i16));
        memrev16ifbe(&i16);
        ret = i16;
    } else if (encoding == ZIP_INT_32B) {
        memcpy(&i32,p,sizeof(i32));
        memrev32ifbe(&i32);
        ret = i32;
    } else if (encoding == ZIP_INT_24B) {
        i32 = 0;
        memcpy(((uint8_t*)&i32)+1,p,sizeof(i32)-sizeof(uint8_t));
        memrev32ifbe(&i32);
        ret = i32>>8;
    } else if (encoding == ZIP_INT_64B) {
        memcpy(&i64,p,sizeof(i64));
        memrev64ifbe(&i64);
        ret = i64;
    } else if (encoding >= ZIP_INT_IMM_MIN && encoding <= ZIP_INT_IMM_MAX) {
        ret = (encoding & ZIP_INT_IMM_MASK)-1;
    } else {
        assert(NULL);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq $0x0, -0x20(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0xfe, %eax
jne 0x402f6
movq -0x8(%rbp), %rax
movsbq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x403ec
movzbl -0x9(%rbp), %eax
cmpl $0xc0, %eax
jne 0x4031a
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movswq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x403ea
movzbl -0x9(%rbp), %eax
cmpl $0xd0, %eax
jne 0x4033b
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x403e8
movzbl -0x9(%rbp), %eax
cmpl $0xf0, %eax
jne 0x4036c
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw (%rax), %cx
movw %cx, -0xf(%rbp)
movb 0x2(%rax), %al
movb %al, -0xd(%rbp)
movl -0x10(%rbp), %eax
sarl $0x8, %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0x403e6
movzbl -0x9(%rbp), %eax
cmpl $0xe0, %eax
jne 0x4038c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x403e4
movzbl -0x9(%rbp), %eax
cmpl $0xf1, %eax
jl 0x403b4
movzbl -0x9(%rbp), %eax
cmpl $0xfd, %eax
jg 0x403b4
movzbl -0x9(%rbp), %eax
andl $0xf, %eax
subl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0x403e2
xorl %eax, %eax
testb $0x1, %al
jne 0x403bc
jmp 0x403be
jmp 0x403e0
leaq 0xfd95a(%rip), %rdi     # 0x13dd1f
leaq 0xfa51c(%rip), %rsi     # 0x13a8e8
movl $0x19b, %edx            # imm = 0x19B
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
jmp 0x403e2
jmp 0x403e4
jmp 0x403e6
jmp 0x403e8
jmp 0x403ea
jmp 0x403ec
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistNew
unsigned char *ziplistNew(void) {
    unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
    unsigned char *zl = zmalloc(bytes);
    ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
    ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);
    ZIPLIST_LENGTH(zl) = 0;
    zl[bytes-1] = ZIP_END;
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xb, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %edi
callq 0x3acd0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0xa, 0x4(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistResize
unsigned char *ziplistResize(unsigned char *zl, unsigned int len) {
    zl = zrealloc(zl,len);
    ZIPLIST_BYTES(zl) = intrev32ifbe(len);
    zl[len-1] = ZIP_END;
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x3ae40
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistNext
unsigned char *ziplistNext(unsigned char *zl, unsigned char *p) {
    ((void) zl);

    /* "p" could be equal to ZIP_END, caused by ziplistDelete,
     * and we should return NULL. Otherwise, we should return NULL
     * when the *next* element is ZIP_END (there is no next entry). */
    if (p[0] == ZIP_END) {
        return NULL;
    }

    p += zipRawEntryLength(p);
    if (p[0] == ZIP_END) {
        return NULL;
    }

    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x41308
movq $0x0, -0x8(%rbp)
jmp 0x41340
movq -0x18(%rbp), %rdi
callq 0x3ff20
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x41338
movq $0x0, -0x8(%rbp)
jmp 0x41340
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/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistPrev
unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p) {
    unsigned int prevlensize, prevlen = 0;

    /* Iterating backwards from ZIP_END should return the tail. When "p" is
     * equal to the first element of the list, we're already at the head,
     * and should return NULL. */
    if (p[0] == ZIP_END) {
        p = ZIPLIST_ENTRY_TAIL(zl);
        return (p[0] == ZIP_END) ? NULL : p;
    } else if (p == ZIPLIST_ENTRY_HEAD(zl)) {
        return NULL;
    } else {
        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);
        assert(prevlen > 0);
        return p-prevlen;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x413b2
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x4139d
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x413a5
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x41459
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0xa, %rcx
cmpq %rcx, %rax
jne 0x413d0
movq $0x0, -0x8(%rbp)
jmp 0x41459
jmp 0x413d2
jmp 0x413d4
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jge 0x413eb
movl $0x1, -0x1c(%rbp)
jmp 0x413f2
movl $0x5, -0x1c(%rbp)
jmp 0x413f4
cmpl $0x1, -0x1c(%rbp)
jne 0x41406
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x41418
cmpl $0x5, -0x1c(%rbp)
jne 0x41416
movq -0x18(%rbp), %rax
movl 0x1(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x41418
jmp 0x4141a
cmpl $0x0, -0x20(%rbp)
jbe 0x41422
jmp 0x41444
leaq 0xf94c9(%rip), %rdi     # 0x13a8f2
leaq 0xf94b8(%rip), %rsi     # 0x13a8e8
movl $0x364, %edx            # imm = 0x364
callq 0x76ce0
movl $0x1, %edi
callq 0x263c0
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %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/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistGet
unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *slen, long long *sval) {
    zlentry entry;
    if (p == NULL || p[0] == ZIP_END) return 0;
    if (sstr) *sstr = NULL;

    zipEntry(p, &entry);
    if (ZIP_IS_STR(entry.encoding)) {
        if (sstr) {
            *slen = entry.len;
            *sstr = p+entry.headersize;
        }
    } else {
        if (sval) {
            *sval = zipLoadInteger(p+entry.headersize,entry.encoding);
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4149d
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x414a6
movl $0x0, -0x4(%rbp)
jmp 0x41525
cmpq $0x0, -0x18(%rbp)
je 0x414b8
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x40400
movzbl -0x34(%rbp), %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jge 0x414f8
cmpq $0x0, -0x18(%rbp)
je 0x414f6
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl -0x38(%rbp), %eax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4151e
cmpq $0x0, -0x28(%rbp)
je 0x4151c
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
addq %rax, %rdi
movzbl -0x34(%rbp), %esi
callq 0x402c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4151e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/ziplist.c
// Function: ziplistDelete
unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
    size_t offset = *p-zl;
    zl = __ziplistDelete(zl,*p,1);

    /* Store pointer to current element in p, because ziplistDelete will
     * do a realloc which might result in a different "zl"-pointer.
     * When the delete direction is back to front, we might delete the last
     * entry and end up with "p" pointing to ZIP_END, so check this. */
    *p = zl+offset;
    return zl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x408b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)