LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/redis-check-rdb.c
// Function: rdbCheckError
void rdbCheckError(const char *fmt, ...) {
    char msg[1024];
    va_list ap;

    va_start(ap, fmt);
    vsnprintf(msg, sizeof(msg), fmt, ap);
    va_end(ap);

    printf("--- RDB ERROR DETECTED ---\n");
    printf("[offset %llu] %s\n",
        (unsigned long long) (rdbstate.rio ?
            rdbstate.rio->processed_bytes : 0), msg);
    printf("[additional info] While doing: %s\n",
        rdb_check_doing_string[rdbstate.doing]);
    if (rdbstate.key)
        printf("[additional info] Reading key '%s'\n",
            (char*)rdbstate.key->ptr);
    if (rdbstate.key_type != -1)
        printf("[additional info] Reading type %d (%s)\n",
            rdbstate.key_type,
            ((unsigned)rdbstate.key_type <
             sizeof(rdb_type_string)/sizeof(char*)) ?
                rdb_type_string[rdbstate.key_type] : "unknown");
    rdbShowGenericInfo();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x500, %rsp            # imm = 0x500
testb %al, %al
je 0xa2c77
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdx, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x430(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x430(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x26810
leaq -0x430(%rbp), %rax
leaq 0xa64cb(%rip), %rdi     # 0x1491ba
movb $0x0, %al
callq 0x260a0
cmpq $0x0, 0xea5ca(%rip)     # 0x18d2c8
je 0xa2d14
movq 0xea5c1(%rip), %rax     # 0x18d2c8
movq 0x30(%rax), %rax
movq %rax, -0x4e8(%rbp)
jmp 0xa2d1f
xorl %eax, %eax
movq %rax, -0x4e8(%rbp)
jmp 0xa2d1f
movq -0x4e8(%rbp), %rsi
leaq -0x410(%rbp), %rdx
leaq 0xa64a2(%rip), %rdi     # 0x1491d6
movb $0x0, %al
callq 0x260a0
movslq 0xea5b6(%rip), %rcx     # 0x18d2f8
leaq 0xd4a17(%rip), %rax     # 0x177760
movq (%rax,%rcx,8), %rsi
leaq 0xa6494(%rip), %rdi     # 0x1491e8
movb $0x0, %al
callq 0x260a0
cmpq $0x0, 0xea56d(%rip)     # 0x18d2d0
je 0xa2d7e
movq 0xea564(%rip), %rax     # 0x18d2d0
movq 0x8(%rax), %rsi
leaq 0xa6494(%rip), %rdi     # 0x14920b
movb $0x0, %al
callq 0x260a0
cmpl $-0x1, 0xea553(%rip)    # 0x18d2d8
je 0xa2de5
movl 0xea54b(%rip), %eax     # 0x18d2d8
movl %eax, -0x4ec(%rbp)
movl 0xea53f(%rip), %eax     # 0x18d2d8
cmpq $0xf, %rax
jae 0xa2dba
movslq 0xea532(%rip), %rcx     # 0x18d2d8
leaq 0xd49f3(%rip), %rax     # 0x1777a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x4f8(%rbp)
jmp 0xa2dca
leaq 0x98a5c(%rip), %rax     # 0x13b81d
movq %rax, -0x4f8(%rbp)
jmp 0xa2dca
movl -0x4ec(%rbp), %esi
movq -0x4f8(%rbp), %rdx
leaq 0xa6451(%rip), %rdi     # 0x14922f
movb $0x0, %al
callq 0x260a0
callq 0xa2be0
addq $0x500, %rsp            # imm = 0x500
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/redis-check-rdb.c
// Function: rdbCheckInfo
void rdbCheckInfo(const char *fmt, ...) {
    char msg[1024];
    va_list ap;

    va_start(ap, fmt);
    vsnprintf(msg, sizeof(msg), fmt, ap);
    va_end(ap);

    printf("[offset %llu] %s\n",
        (unsigned long long) (rdbstate.rio ?
            rdbstate.rio->processed_bytes : 0), msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4f0, %rsp            # imm = 0x4F0
testb %al, %al
je 0xa2e47
movaps %xmm0, -0x4b0(%rbp)
movaps %xmm1, -0x4a0(%rbp)
movaps %xmm2, -0x490(%rbp)
movaps %xmm3, -0x480(%rbp)
movaps %xmm4, -0x470(%rbp)
movaps %xmm5, -0x460(%rbp)
movaps %xmm6, -0x450(%rbp)
movaps %xmm7, -0x440(%rbp)
movq %r9, -0x4b8(%rbp)
movq %r8, -0x4c0(%rbp)
movq %rcx, -0x4c8(%rbp)
movq %rdx, -0x4d0(%rbp)
movq %rsi, -0x4d8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x430(%rbp), %rax
leaq -0x4e0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq -0x430(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x26810
leaq -0x430(%rbp), %rax
cmpq $0x0, 0xea408(%rip)     # 0x18d2c8
je 0xa2ed6
movq 0xea3ff(%rip), %rax     # 0x18d2c8
movq 0x30(%rax), %rax
movq %rax, -0x4e8(%rbp)
jmp 0xa2ee1
xorl %eax, %eax
movq %rax, -0x4e8(%rbp)
jmp 0xa2ee1
movq -0x4e8(%rbp), %rsi
leaq 0xa62e7(%rip), %rdi     # 0x1491d6
xorl %eax, %eax
leaq -0x410(%rbp), %rdx
callq 0x260a0
addq $0x4f0, %rsp            # imm = 0x4F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/redis-check-rdb.c
// Function: rdbCheckSetError
void rdbCheckSetError(const char *fmt, ...) {
    va_list ap;

    va_start(ap, fmt);
    vsnprintf(rdbstate.error, sizeof(rdbstate.error), fmt, ap);
    va_end(ap);
    rdbstate.error_set = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xa2f45
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdx
leaq 0xea368(%rip), %rdi     # 0x18d300
movl $0x400, %esi            # imm = 0x400
leaq -0x20(%rbp), %rcx
callq 0x26810
movl $0x1, 0xea34c(%rip)     # 0x18d2fc
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/redis-check-rdb.c
// Function: rdbCheckSetupSignals
void rdbCheckSetupSignals(void) {
    struct sigaction act;

    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
    act.sa_sigaction = rdbCheckHandleCrash;
    sigaction(SIGSEGV, &act, NULL);
    sigaction(SIGBUS, &act, NULL);
    sigaction(SIGFPE, &act, NULL);
    sigaction(SIGILL, &act, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x26ac0
movl $0xc0000004, -0x10(%rbp) # imm = 0xC0000004
leaq -0x59(%rip), %rax       # 0xa2fc0
movq %rax, -0x98(%rbp)
movl $0xb, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x266d0
movl $0x7, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x266d0
movl $0x8, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x266d0
movl $0x4, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x266d0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/redis-check-rdb.c
// Function: redis_check_rdb_main
int redis_check_rdb_main(int argc, char **argv) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <rdb-file-name>\n", argv[0]);
        exit(1);
    }
    createSharedObjects(); /* Needed for loading. */
    server.loading_process_events_interval_bytes = 0;
    rdbCheckMode = 1;
    rdbCheckInfo("Checking RDB file %s", argv[1]);
    rdbCheckSetupSignals();
    int retval = redis_check_rdb(argv[1]);
    if (retval == 0) {
        rdbCheckInfo("\\o/ RDB looks OK! \\o/");
        rdbShowGenericInfo();
    }
    exit(retval);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x4(%rbp)
je 0xa374e
movq 0xcf8bc(%rip), %rax     # 0x172fe8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xa5b93(%rip), %rsi     # 0x1492d0
movb $0x0, %al
callq 0x26ba0
movl $0x1, %edi
callq 0x262d0
callq 0x319f0
leaq 0xd4a7e(%rip), %rax     # 0x1781d8
movq $0x0, 0x338(%rax)
movl $0x1, 0xe9b51(%rip)     # 0x18d2c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xa5b6d(%rip), %rdi     # 0x1492eb
movb $0x0, %al
callq 0xa2e00
callq 0xa2ff0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa3080
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xa37b3
leaq 0xa5b59(%rip), %rdi     # 0x149300
movb $0x0, %al
callq 0xa2e00
callq 0xa2be0
movl -0x14(%rbp), %edi
callq 0x262d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: geoArrayCreate
geoArray *geoArrayCreate(void) {
    geoArray *ga = zmalloc(sizeof(*ga));
    /* It gets allocated on first geoArrayAppend() call. */
    ga->array = NULL;
    ga->buckets = 0;
    ga->used = 0;
    return ga;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x3acd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
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/geo.c
// Function: geoArrayAppend
geoPoint *geoArrayAppend(geoArray *ga) {
    if (ga->used == ga->buckets) {
        ga->buckets = (ga->buckets == 0) ? 8 : ga->buckets*2;
        ga->array = zrealloc(ga->array,sizeof(geoPoint)*ga->buckets);
    }
    geoPoint *gp = ga->array+ga->used;
    ga->used++;
    return gp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xa387e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa3844
movl $0x8, %eax
movq %rax, -0x18(%rbp)
jmp 0xa3853
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x28, 0x8(%rax), %rsi
callq 0x3ae40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
imulq $0x28, 0x10(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: geoArrayFree
void geoArrayFree(geoArray *ga) {
    size_t i;
    for (i = 0; i < ga->used; i++) sdsfree(ga->array[i].member);
    zfree(ga->array);
    zfree(ga);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xa38f8
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x38620
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa38c4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3afa0
movq -0x8(%rbp), %rdi
callq 0x3afa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: extractLongLatOrReply
int extractLongLatOrReply(client *c, robj **argv, double *xy) {
    int i;
    for (i = 0; i < 2; i++) {
        if (getDoubleFromObjectOrReply(c, argv[i], xy + i, NULL) !=
            C_OK) {
            return C_ERR;
        }
    }
    if (xy[0] < GEO_LONG_MIN || xy[0] > GEO_LONG_MAX ||
        xy[1] < GEO_LAT_MIN  || xy[1] > GEO_LAT_MAX) {
        addReplySds(c, sdscatprintf(sdsempty(),
            "-ERR invalid longitude,latitude pair %f,%f\r\n",xy[0],xy[1]));
        return C_ERR;
    }
    return C_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x2, -0x24(%rbp)
jge 0xa39e7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rdx
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x49b10
cmpl $0x0, %eax
je 0xa39da
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3a84
jmp 0xa39dc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa399b
movq -0x20(%rbp), %rax
movsd 0xa5925(%rip), %xmm0    # 0x149318
ucomisd (%rax), %xmm0
ja 0xa3a39
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd 0xa5917(%rip), %xmm1    # 0x149320
ucomisd %xmm1, %xmm0
ja 0xa3a39
movq -0x20(%rbp), %rax
movsd 0xa590d(%rip), %xmm0    # 0x149328
ucomisd 0x8(%rax), %xmm0
ja 0xa3a39
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0xa58fd(%rip), %xmm1    # 0x149330
ucomisd %xmm1, %xmm0
jbe 0xa3a7d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x384f0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq 0xa5913(%rip), %rsi     # 0x149374
movb $0x2, %al
callq 0x395b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x42e50
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3a84
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/geo.c
// Function: longLatFromMember
int longLatFromMember(robj *zobj, robj *member, double *xy) {
    double score = 0;

    if (zsetScore(zobj, member, &score) == C_ERR) return C_ERR;
    if (!decodeGeohash(score, xy)) return C_ERR;
    return C_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x61520
cmpl $-0x1, %eax
jne 0xa3acb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3aee
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rdi
callq 0xa3920
cmpl $0x0, %eax
jne 0xa3ae7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3aee
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: extractUnitOrReply
double extractUnitOrReply(client *c, robj *unit) {
    char *u = unit->ptr;

    if (!strcmp(u, "m")) {
        return 1;
    } else if (!strcmp(u, "km")) {
        return 1000;
    } else if (!strcmp(u, "ft")) {
        return 0.3048;
    } else if (!strcmp(u, "mi")) {
        return 1609.34;
    } else {
        addReplyError(c,
            "unsupported unit provided. please use m, km, ft, mi");
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xa54fd(%rip), %rsi     # 0x149024
callq 0x268f0
cmpl $0x0, %eax
jne 0xa3b43
movsd 0x9392f(%rip), %xmm0    # 0x137468
movsd %xmm0, -0x8(%rbp)
jmp 0xa3bcc
movq -0x20(%rbp), %rdi
leaq 0xa5853(%rip), %rsi     # 0x1493a1
callq 0x268f0
cmpl $0x0, %eax
jne 0xa3b67
movsd 0xa57d8(%rip), %xmm0    # 0x149338
movsd %xmm0, -0x8(%rbp)
jmp 0xa3bcc
movq -0x20(%rbp), %rdi
leaq 0xa879b(%rip), %rsi     # 0x14c30d
callq 0x268f0
cmpl $0x0, %eax
jne 0xa3b8b
movsd 0xa57bc(%rip), %xmm0    # 0x149340
movsd %xmm0, -0x8(%rbp)
jmp 0xa3bcc
movq -0x20(%rbp), %rdi
leaq 0xa583f(%rip), %rsi     # 0x1493d5
callq 0x268f0
cmpl $0x0, %eax
jne 0xa3baf
movsd 0xa57a0(%rip), %xmm0    # 0x149348
movsd %xmm0, -0x8(%rbp)
jmp 0xa3bcc
movq -0x10(%rbp), %rdi
leaq 0xa57ea(%rip), %rsi     # 0x1493a4
callq 0x42f90
movsd 0x93899(%rip), %xmm0    # 0x137460
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: extractDistanceOrReply
double extractDistanceOrReply(client *c, robj **argv,
                                     double *conversion) {
    double distance;
    if (getDoubleFromObjectOrReply(c, argv[0], &distance,
                                   "need numeric radius") != C_OK) {
        return -1;
    }

    if (distance < 0) {
        addReplyError(c,"radius cannot be negative");
        return -1;
    }
    
    double to_meters = extractUnitOrReply(c,argv[1]);
    if (to_meters < 0) {
        return -1;
    }

    if (conversion) *conversion = to_meters;
    return distance * to_meters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x28(%rbp), %rdx
leaq 0xa57ce(%rip), %rcx     # 0x1493d8
callq 0x49b10
cmpl $0x0, %eax
je 0xa3c23
movsd 0x93844(%rip), %xmm0    # 0x137460
movsd %xmm0, -0x8(%rbp)
jmp 0xa3c9e
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0xa3c4c
movq -0x10(%rbp), %rdi
leaq 0xa57b4(%rip), %rsi     # 0x1493ec
callq 0x42f90
movsd 0x9381b(%rip), %xmm0    # 0x137460
movsd %xmm0, -0x8(%rbp)
jmp 0xa3c9e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa3b00
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0xa3c7b
movsd 0x937ec(%rip), %xmm0    # 0x137460
movsd %xmm0, -0x8(%rbp)
jmp 0xa3c9e
cmpq $0x0, -0x20(%rbp)
je 0xa3c8f
movsd -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: geoAppendIfWithinRadius
int geoAppendIfWithinRadius(geoArray *ga, double lon, double lat, double radius, double score, sds member) {
    double distance, xy[2];

    if (!decodeGeohash(score,xy)) return C_ERR; /* Can't decode. */
    /* Note that geohashGetDistanceIfInRadiusWGS84() takes arguments in
     * reverse order: longitude first, latitude later. */
    if (!geohashGetDistanceIfInRadiusWGS84(lon,lat, xy[0], xy[1],
                                           radius, &distance))
    {
        return C_ERR;
    }

    /* Append the new element. */
    geoPoint *gp = geoArrayAppend(ga);
    gp->longitude = xy[0];
    gp->latitude = xy[1];
    gp->dist = distance;
    gp->member = member;
    gp->score = score;
    return C_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd %xmm2, -0x28(%rbp)
movsd %xmm3, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0xa3920
cmpl $0x0, %eax
jne 0xa3d53
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3dda
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd -0x50(%rbp), %xmm2
movsd -0x48(%rbp), %xmm3
movsd -0x28(%rbp), %xmm4
leaq -0x40(%rbp), %rdi
callq 0xd4c70
cmpl $0x0, %eax
jne 0xa3d83
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa3dda
movq -0x10(%rbp), %rdi
callq 0xa3810
movq %rax, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
movq -0x58(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x48(%rbp), %xmm0
movq -0x58(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x40(%rbp), %xmm0
movq -0x58(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x20(%rax)
movsd -0x30(%rbp), %xmm0
movq -0x58(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: scoresOfGeoHashBox
void scoresOfGeoHashBox(GeoHashBits hash, GeoHashFix52Bits *min, GeoHashFix52Bits *max) {
    /* We want to compute the sorted set scores that will include all the
     * elements inside the specified Geohash 'hash', which has as many
     * bits as specified by hash.step * 2.
     *
     * So if step is, for example, 3, and the hash value in binary
     * is 101010, since our score is 52 bits we want every element which
     * is in binary: 101010?????????????????????????????????????????????
     * Where ? can be 0 or 1.
     *
     * To get the min score we just use the initial hash value left
     * shifted enough to get the 52 bit value. Later we increment the
     * 6 bit prefis (see the hash.bits++ statement), and get the new
     * prefix: 101011, which we align again to 52 bits to get the maximum
     * value (which is excluded from the search). So we get everything
     * between the two following scores (represented in binary):
     *
     * 1010100000000000000000000000000000000000000000000000 (included)
     * and
     * 1010110000000000000000000000000000000000000000000000 (excluded).
     */
    *min = geohashAlign52Bits(hash);
    hash.bits++;
    *max = geohashAlign52Bits(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x8(%rbp), %esi
callq 0xd4bc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x8(%rbp), %esi
callq 0xd4bc0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: sort_gp_asc
static int sort_gp_asc(const void *a, const void *b) {
    const struct geoPoint *gpa = a, *gpb = b;
    /* We can't do adist - bdist because they are doubles and
     * the comparator returns an int. */
    if (gpa->dist > gpb->dist)
        return 1;
    else if (gpa->dist == gpb->dist)
        return 0;
    else
        return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0xa5599
movl $0x1, -0x4(%rbp)
jmp 0xa55bf
movq -0x20(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x28(%rbp), %rax
ucomisd 0x10(%rax), %xmm0
jne 0xa55b8
jp 0xa55b8
movl $0x0, -0x4(%rbp)
jmp 0xa55bf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: geoposCommand
void geoposCommand(client *c) {
    int j;

    /* Look up the requested zset */
    robj *zobj = NULL;
    if ((zobj = lookupKeyReadOrReply(c, c->argv[1], shared.emptymultibulk))
        == NULL || checkType(c, zobj, OBJ_ZSET)) return;

    /* Report elements one after the other, using a null bulk reply for
     * missing elements. */
    addReplyMultiBulkLen(c,c->argc-2);
    for (j = 2; j < c->argc; j++) {
        double score;
        if (zsetScore(zobj, c->argv[j], &score) == C_ERR) {
            addReply(c,shared.nullmultibulk);
        } else {
            /* Decode... */
            double xy[2];
            if (!decodeGeohash(score,xy)) {
                addReply(c,shared.nullmultibulk);
                continue;
            }
            addReplyMultiBulkLen(c,2);
            addReplyHumanLongDouble(c,xy[0]);
            addReplyHumanLongDouble(c,xy[1]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0xd3325(%rip), %rax     # 0x178c40
movq 0x68(%rax), %rdx
callq 0x4a730
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa5945
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0xa594a
jmp 0xa5a18
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
subl $0x2, %eax
movslq %eax, %rsi
callq 0x437f0
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xa5a18
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x20(%rbp), %rdx
callq 0x61520
cmpl $-0x1, %eax
jne 0xa59af
movq -0x8(%rbp), %rdi
leaq 0xd329c(%rip), %rax     # 0x178c40
movq 0x58(%rax), %rsi
callq 0x42cc0
jmp 0xa5a08
movsd -0x20(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0xa3920
cmpl $0x0, %eax
jne 0xa59d8
movq -0x8(%rbp), %rdi
leaq 0xd3273(%rip), %rax     # 0x178c40
movq 0x58(%rax), %rsi
callq 0x42cc0
jmp 0xa5a0a
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x437f0
movq -0x8(%rbp), %rdi
fldl -0x30(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x435e0
movq -0x8(%rbp), %rdi
fldl -0x28(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x435e0
jmp 0xa5a0a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa5967
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/src/geo.c
// Function: geodistCommand
void geodistCommand(client *c) {
    double to_meter = 1;

    /* Check if there is the unit to extract, otherwise assume meters. */
    if (c->argc == 5) {
        to_meter = extractUnitOrReply(c,c->argv[4]);
        if (to_meter < 0) return;
    } else if (c->argc > 5) {
        addReply(c,shared.syntaxerr);
        return;
    }

    /* Look up the requested zset */
    robj *zobj = NULL;
    if ((zobj = lookupKeyReadOrReply(c, c->argv[1], shared.emptybulk))
        == NULL || checkType(c, zobj, OBJ_ZSET)) return;

    /* Get the scores. We need both otherwise NULL is returned. */
    double score1, score2, xyxy[4];
    if (zsetScore(zobj, c->argv[2], &score1) == C_ERR ||
        zsetScore(zobj, c->argv[3], &score2) == C_ERR)
    {
        addReply(c,shared.nullbulk);
        return;
    }

    /* Decode & compute the distance. */
    if (!decodeGeohash(score1,xyxy) || !decodeGeohash(score2,xyxy+2))
        addReply(c,shared.nullbulk);
    else
        addReplyDoubleDistance(c,
            geohashGetDistance(xyxy[0],xyxy[1],xyxy[2],xyxy[3]) / to_meter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movsd 0x91a34(%rip), %xmm0    # 0x137468
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, 0x38(%rax)
jne 0xa5a6e
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x20(%rax), %rsi
callq 0xa3b00
movsd %xmm0, -0x10(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0xa5a6c
jmp 0xa5ba5
jmp 0xa5a96
movq -0x8(%rbp), %rax
cmpl $0x5, 0x38(%rax)
jle 0xa5a94
movq -0x8(%rbp), %rdi
leaq 0xd31bd(%rip), %rax     # 0x178c40
movq 0x80(%rax), %rsi
callq 0x42cc0
jmp 0xa5ba5
jmp 0xa5a96
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0xd318b(%rip), %rax     # 0x178c40
movq 0x18(%rax), %rdx
callq 0x4a730
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xa5adf
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x3, %edx
callq 0x490a0
cmpl $0x0, %eax
je 0xa5ae4
jmp 0xa5ba5
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x61520
cmpl $-0x1, %eax
je 0xa5b20
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rsi
leaq -0x28(%rbp), %rdx
callq 0x61520
cmpl $-0x1, %eax
jne 0xa5b36
movq -0x8(%rbp), %rdi
leaq 0xd3115(%rip), %rax     # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0xa5ba5
movsd -0x20(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0xa3920
cmpl $0x0, %eax
je 0xa5b60
movsd -0x28(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
addq $0x10, %rdi
callq 0xa3920
cmpl $0x0, %eax
jne 0xa5b76
movq -0x8(%rbp), %rdi
leaq 0xd30d5(%rip), %rax     # 0x178c40
movq 0x50(%rax), %rsi
callq 0x42cc0
jmp 0xa5ba5
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd -0x50(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movsd -0x40(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
callq 0xd4a70
movq -0x58(%rbp), %rdi
divsd -0x10(%rbp), %xmm0
callq 0xa3cb0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/hiredis/async.c
// Function: redisvAsyncCommand
int redisvAsyncCommand(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, const char *format, va_list ap) {
    char *cmd;
    int len;
    int status;
    len = redisvFormatCommand(&cmd,format,ap);
    status = __redisAsyncCommand(ac,fn,privdata,cmd,len);
    free(cmd);
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xa92d0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movslq -0x34(%rbp), %r8
callq 0xa6bd0
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x264c0
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/hiredis/async.c
// Function: redisAsyncCommandArgv
int redisAsyncCommandArgv(redisAsyncContext *ac, redisCallbackFn *fn, void *privdata, int argc, const char **argv, const size_t *argvlen) {
    char *cmd;
    int len;
    int status;
    len = redisFormatCommandArgv(&cmd,argc,argv,argvlen);
    status = __redisAsyncCommand(ac,fn,privdata,cmd,len);
    free(cmd);
    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x1c(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %rdi
callq 0xaa0b0
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rcx
movslq -0x3c(%rbp), %r8
callq 0xa6bd0
movl %eax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x264c0
movl -0x40(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/hiredis/async.c
// Function: nextArgument
static char *nextArgument(char *start, char **str, size_t *len) {
    char *p = start;
    if (p[0] != '$') {
        p = strchr(p,'$');
        if (p == NULL) return NULL;
    }

    *len = (int)strtol(p+1,NULL,10);
    p = strchr(p,'\r');
    assert(p);
    *str = p+2;
    return p+2+(*len)+2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
je 0xa7720
movq -0x28(%rbp), %rdi
movl $0x24, %esi
callq 0x267f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xa771e
movq $0x0, -0x8(%rbp)
jmp 0xa77a0
jmp 0xa7720
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x26720
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movl $0xd, %esi
callq 0x267f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa775b
jmp 0xa777a
leaq 0x9a6f4(%rip), %rdi     # 0x141e56
leaq 0xa1f1c(%rip), %rsi     # 0x149685
movl $0x233, %edx            # imm = 0x233
leaq 0xa2104(%rip), %rcx     # 0x149879
callq 0x262e0
movq -0x28(%rbp), %rcx
addq $0x2, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq -0x20(%rbp), %rcx
addq (%rcx), %rax
addq $0x2, %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/gplessis[P]dotdeb-redis/deps/hiredis/./dict.c
// Function: dictReplace
static int dictReplace(dict *ht, void *key, void *val) {
    dictEntry *entry, auxentry;

    /* Try to add the element. If the key
     * does not exists dictAdd will suceed. */
    if (dictAdd(ht, key, val) == DICT_OK)
        return 1;
    /* It already exists, get the entry */
    entry = dictFind(ht, key);
    /* Free the old value and set the new one */
    /* Set the new value and free the old one. Note that it is important
     * to do that in this order, as the value may just be exactly the same
     * as the previous one. In this context, think to reference counting,
     * you want to increment (set), and then decrement (free), and not the
     * reverse. */
    auxentry = *entry;
    dictSetHashVal(ht, entry, val);
    dictFreeEntryVal(ht, &auxentry);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa7890
cmpl $0x0, %eax
jne 0xa77e6
movl $0x1, -0x4(%rbp)
jmp 0xa7886
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa7470
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xa7848
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xa7854
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xa7856
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0xa787f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/hiredis/./dict.c
// Function: dictExpandIfNeeded
static int _dictExpandIfNeeded(dict *ht) {
    /* If the hash table is empty expand it to the intial size,
     * if the table is "full" dobule its size. */
    if (ht->size == 0)
        return dictExpand(ht, DICT_HT_INITIAL_SIZE);
    if (ht->used == ht->size)
        return dictExpand(ht, ht->size*2);
    return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xa7aaa
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0xa7af0
movl %eax, -0x4(%rbp)
jmp 0xa7adc
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xa7ad5
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
shlq %rsi
callq 0xa7af0
movl %eax, -0x4(%rbp)
jmp 0xa7adc
movl $0x0, -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/deps/lua/src/lua_cjson.c
// Function: luaopen_cjson
int luaopen_cjson(lua_State *l)
{
    lua_cjson_new(l);

#ifdef ENABLE_CJSON_GLOBAL
    /* Register a global "cjson" table. */
    lua_pushvalue(l, -1);
    lua_setglobal(l, CJSON_MODNAME);
#endif

    /* Return cjson table */
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc8ae0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xaca40
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x7b1e4(%rip), %rdx     # 0x143ca7
callq 0xadca0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: lua_cjson_new
static int lua_cjson_new(lua_State *l)
{
    luaL_Reg reg[] = {
        { "encode", json_encode },
        { "decode", json_decode },
        { "encode_sparse_array", json_cfg_encode_sparse_array },
        { "encode_max_depth", json_cfg_encode_max_depth },
        { "decode_max_depth", json_cfg_decode_max_depth },
        { "encode_number_precision", json_cfg_encode_number_precision },
        { "encode_keep_buffer", json_cfg_encode_keep_buffer },
        { "encode_invalid_numbers", json_cfg_encode_invalid_numbers },
        { "decode_invalid_numbers", json_cfg_decode_invalid_numbers },
        { "new", lua_cjson_new },
        { NULL, NULL }
    };

    /* Initialise number conversions */
    fpconv_init();

    /* cjson module table */
    lua_newtable(l);

    /* Register functions with config data as upvalue */
    json_create_config(l);
    luaL_setfuncs(l, reg, 1);

    /* Set cjson.null */
    lua_pushlightuserdata(l, NULL);
    lua_setfield(l, -2, "null");

    /* Set module name / version fields */
    lua_pushliteral(l, CJSON_MODNAME);
    lua_setfield(l, -2, "_NAME");
    lua_pushliteral(l, CJSON_VERSION);
    lua_setfield(l, -2, "_VERSION");

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq 0xa8603(%rip), %rsi     # 0x171100
movl $0xb0, %edx
callq 0x26c60
movb $0x0, %al
callq 0xd3460
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xad9e0
movq -0x8(%rbp), %rdi
callq 0xc9160
movq -0x8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
movl $0x1, %edx
callq 0xc9450
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xad760
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x70c01(%rip), %rdx     # 0x139757
callq 0xadca0
movq -0x8(%rbp), %rdi
leaq 0x7b141(%rip), %rsi     # 0x143ca7
movl $0x5, %edx
callq 0xad390
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x82b92(%rip), %rdx     # 0x14b712
callq 0xadca0
movq -0x8(%rbp), %rdi
leaq 0x82b88(%rip), %rsi     # 0x14b718
movl $0x5, %edx
callq 0xad390
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x8207d(%rip), %rdx     # 0x14ac27
callq 0xadca0
movl $0x1, %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: lua_cjson_safe_new
static int lua_cjson_safe_new(lua_State *l)
{
    const char *func[] = { "decode", "encode", NULL };
    int i;

    lua_cjson_new(l);

    /* Fix new() method */
    lua_pushcfunction(l, lua_cjson_safe_new);
    lua_setfield(l, -2, "new");

    for (i = 0; func[i]; i++) {
        lua_getfield(l, -1, func[i]);
        lua_pushcclosure(l, json_protect_conversion, 1);
        lua_setfield(l, -2, func[i]);
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa85bd(%rip), %rax     # 0x1711b0
movq %rax, -0x20(%rbp)
movq 0xa85ba(%rip), %rax     # 0x1711b8
movq %rax, -0x18(%rbp)
movq 0xa85b7(%rip), %rax     # 0x1711c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc8ae0
movq -0x8(%rbp), %rdi
leaq -0x41(%rip), %rsi       # 0xc8be0
xorl %edx, %edx
callq 0xad5a0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x82ad6(%rip), %rdx     # 0x14b70e
callq 0xadca0
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq $0x0, -0x20(%rbp,%rax,8)
je 0xc8c9e
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq -0x20(%rbp,%rax,8), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xad850
movq -0x8(%rbp), %rdi
leaq 0x231e(%rip), %rsi      # 0xcaf90
movl $0x1, %edx
callq 0xad5a0
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq -0x20(%rbp,%rax,8), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0xadca0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc8c44
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_encode
static int json_encode(lua_State *l)
{
    json_config_t *cfg = json_fetch_config(l);
    strbuf_t local_encode_buf;
    strbuf_t *encode_buf;
    char *json;
    int len;

    luaL_argcheck(l, lua_gettop(l) == 1, 1, "expected 1 argument");

    if (!cfg->encode_keep_buffer) {
        /* Use private buffer */
        encode_buf = &local_encode_buf;
        strbuf_init(encode_buf, 0);
    } else {
        /* Reuse existing buffer */
        encode_buf = &cfg->encode_buf;
        strbuf_reset(encode_buf);
    }

    json_append_data(l, cfg, 0, encode_buf);
    json = strbuf_string(encode_buf, &len);

    lua_pushlstring(l, json, len);

    if (!cfg->encode_keep_buffer)
        strbuf_free(encode_buf);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc9500
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xac540
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x45(%rbp)
je 0xc8cfc
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x82a30(%rip), %rdx     # 0x14b71e
callq 0xc0270
cmpl $0x0, %eax
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
movq -0x10(%rbp), %rax
cmpl $0x0, 0x538(%rax)
jne 0xc8d21
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xd2990
jmp 0xc8d38
movq -0x10(%rbp), %rax
addq $0x500, %rax            # imm = 0x500
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xc9550
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rcx
xorl %edx, %edx
callq 0xc9570
movq -0x38(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0xc9700
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq -0x44(%rbp), %rdx
callq 0xad390
movq -0x10(%rbp), %rax
cmpl $0x0, 0x538(%rax)
jne 0xc8d83
movq -0x38(%rbp), %rdi
callq 0xd2bb0
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_decode
static int json_decode(lua_State *l)
{
    json_parse_t json;
    json_token_t token;
    size_t json_len;

    luaL_argcheck(l, lua_gettop(l) == 1, 1, "expected 1 argument");

    json.cfg = json_fetch_config(l);
    json.data = luaL_checklstring(l, 1, &json_len);
    json.current_depth = 0;
    json.ptr = json.data;

    /* Detect Unicode other than UTF-8 (see RFC 4627, Sec 3)
     *
     * CJSON can support any simple data type, hence only the first
     * character is guaranteed to be ASCII (at worst: '"'). This is
     * still enough to detect whether the wrong encoding is in use. */
    if (json_len >= 2 && (!json.data[0] || !json.data[1]))
        luaL_error(l, "JSON parser does not support UTF-16 or UTF-32");

    /* Ensure the temporary buffer can hold the entire string.
     * This means we no longer need to do length checks since the decoded
     * string must be smaller than the entire json string */
    json.tmp = strbuf_new(json_len);

    json_next_token(&json, &token);
    json_process_value(l, &json, &token);

    /* Ensure there is no more input left */
    json_next_token(&json, &token);

    if (token.type != T_END)
        json_throw_parse_error(l, &json, "the end", &token);

    strbuf_free(json.tmp);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xac540
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x51(%rbp)
je 0xc8dcf
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x8295d(%rip), %rdx     # 0x14b71e
callq 0xc0270
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
movq -0x8(%rbp), %rdi
callq 0xc9500
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq -0x50(%rbp), %rdx
callq 0xc06a0
movq %rax, -0x30(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x2, -0x50(%rbp)
jb 0xc8e30
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc8e1e
movq -0x30(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0xc8e30
movq -0x8(%rbp), %rdi
leaq 0x82aae(%rip), %rsi     # 0x14b8d7
movb $0x0, %al
callq 0xc0370
movq -0x50(%rbp), %rax
movl %eax, %edi
callq 0xd2b20
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc9f70
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0xca1d0
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc9f70
cmpl $0xa, -0x48(%rbp)
je 0xc8e88
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq 0x82a86(%rip), %rdx     # 0x14b905
leaq -0x48(%rbp), %rcx
callq 0xca2a0
movq -0x20(%rbp), %rdi
callq 0xd2bb0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_sparse_array
static int json_cfg_encode_sparse_array(lua_State *l)
{
    json_config_t *cfg = json_arg_init(l, 3);

    json_enum_option(l, 1, &cfg->encode_sparse_convert, NULL, 1);
    json_integer_option(l, 2, &cfg->encode_sparse_ratio, 0, INT_MAX);
    json_integer_option(l, 3, &cfg->encode_sparse_safe, 0, INT_MAX);

    return 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0xcad30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x520, %rdx            # imm = 0x520
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %ecx
movl %r8d, %esi
callq 0xcada0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x524, %rdx            # imm = 0x524
movl $0x2, %esi
xorl %ecx, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xcae90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x528, %rdx            # imm = 0x528
movl $0x3, %esi
xorl %ecx, %ecx
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
callq 0xcae90
movl $0x3, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_keep_buffer
static int json_cfg_encode_keep_buffer(lua_State *l)
{
    json_config_t *cfg = json_arg_init(l, 1);
    int old_value;

    old_value = cfg->encode_keep_buffer;

    json_enum_option(l, 1, &cfg->encode_keep_buffer, NULL, 1);

    /* Init / free the buffer if the setting has changed */
    if (old_value ^ cfg->encode_keep_buffer) {
        if (cfg->encode_keep_buffer)
            strbuf_init(&cfg->encode_buf, 0);
        else
            strbuf_free(&cfg->encode_buf);
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xcad30
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x538(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x538, %rdx            # imm = 0x538
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %ecx
movl %r8d, %esi
callq 0xcada0
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
xorl 0x538(%rcx), %eax
cmpl $0x0, %eax
je 0xc90b1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x538(%rax)
je 0xc909f
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
xorl %esi, %esi
callq 0xd2990
jmp 0xc90af
movq -0x10(%rbp), %rdi
addq $0x500, %rdi            # imm = 0x500
callq 0xd2bb0
jmp 0xc90b1
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_cfg_encode_invalid_numbers
static int json_cfg_encode_invalid_numbers(lua_State *l)
{
    static const char *options[] = { "off", "on", "null", NULL };
    json_config_t *cfg = json_arg_init(l, 1);

    json_enum_option(l, 1, &cfg->encode_invalid_numbers, options, 1);

    json_verify_invalid_number_setting(l, &cfg->encode_invalid_numbers);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xcad30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x530, %rdx            # imm = 0x530
movl $0x1, %r8d
leaq 0xaf016(%rip), %rcx     # 0x178110
movl %r8d, %esi
callq 0xcada0
jmp 0xc9104
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua_cjson.c
// Function: json_cfg_decode_invalid_numbers
static int json_cfg_decode_invalid_numbers(lua_State *l)
{
    json_config_t *cfg = json_arg_init(l, 1);

    json_enum_option(l, 1, &cfg->decode_invalid_numbers, NULL, 1);

    json_verify_invalid_number_setting(l, &cfg->encode_invalid_numbers);

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xcad30
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x53c, %rdx            # imm = 0x53C
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %ecx
movl %r8d, %esi
callq 0xcada0
jmp 0xc9151
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)