LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/memtest.c
// Function: memtest_compare_times
void memtest_compare_times(unsigned long *m, size_t bytes, int pass, int times) {
    int j;

    for (j = 0; j < times; j++) {
        memtest_progress_start("Compare",pass);
        memtest_compare(m,bytes);
        memtest_progress_end();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x37131
movl -0x14(%rbp), %esi
leaq 0x70e8a(%rip), %rdi     # 0xa7f99
callq 0x369c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36fc0
callq 0x36aa0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x370fd
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/memtest.c
// Function: memtest_test
void memtest_test(size_t megabytes, int passes) {
    size_t bytes = megabytes*1024*1024;
    unsigned long *m = malloc(bytes);
    int pass = 0;

    if (m == NULL) {
        fprintf(stderr,"Unable to allocate %zu megabytes: %s",
            megabytes, strerror(errno));
        exit(1);
    }
    while (pass != passes) {
        pass++;

        memtest_progress_start("Addressing test",pass);
        memtest_addressing(m,bytes);
        memtest_progress_end();

        memtest_progress_start("Random fill",pass);
        memtest_fill_random(m,bytes);
        memtest_progress_end();
        memtest_compare_times(m,bytes,pass,4);

        memtest_progress_start("Solid fill",pass);
        memtest_fill_value(m,bytes,0,(unsigned long)-1,'S');
        memtest_progress_end();
        memtest_compare_times(m,bytes,pass,4);

        memtest_progress_start("Checkerboard fill",pass);
        memtest_fill_value(m,bytes,ULONG_ONEZERO,ULONG_ZEROONE,'C');
        memtest_progress_end();
        memtest_compare_times(m,bytes,pass,4);
    }
    free(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
shlq $0xa, %rax
shlq $0xa, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x125b0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x371bf
movq 0x86e77(%rip), %rax     # 0xbdff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x120b0
movl (%rax), %edi
callq 0x12900
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x70df3(%rip), %rsi     # 0xa7fa1
movb $0x0, %al
callq 0x124b0
movl $0x1, %edi
callq 0x12870
jmp 0x371c1
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x372c9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0x70de6(%rip), %rdi     # 0xa7fc6
callq 0x369c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36b50
callq 0x36aa0
movl -0x24(%rbp), %esi
leaq 0x70dd5(%rip), %rdi     # 0xa7fd6
callq 0x369c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36c70
callq 0x36aa0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
movl $0x4, %ecx
callq 0x370e0
movl -0x24(%rbp), %esi
leaq 0x70dab(%rip), %rdi     # 0xa7fe2
callq 0x369c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movq $-0x1, %rcx
movl $0x53, %r8d
callq 0x36e20
callq 0x36aa0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
movl $0x4, %ecx
callq 0x370e0
movl -0x24(%rbp), %esi
leaq 0x70d6f(%rip), %rdi     # 0xa7fed
callq 0x369c0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movabsq $-0x5555555555555556, %rdx # imm = 0xAAAAAAAAAAAAAAAA
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
movl $0x43, %r8d
callq 0x36e20
callq 0x36aa0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
movl $0x4, %ecx
callq 0x370e0
jmp 0x371c1
movq -0x20(%rbp), %rdi
callq 0x12060
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/memtest.c
// Function: memtest_non_destructive_invert
void memtest_non_destructive_invert(void *addr, size_t size) {
    volatile unsigned long *p = addr;
    size_t words = size / sizeof(unsigned long);
    size_t j;

    /* Invert */
    for (j = 0; j < words; j++)
        p[j] = ~p[j];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3733c
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
xorq $-0x1, %rdx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x37308
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/memtest.c
// Function: memtest_non_destructive_swap
void memtest_non_destructive_swap(void *addr, size_t size) {
    volatile unsigned long *p = addr;
    size_t words = size / sizeof(unsigned long);
    size_t j;

    /* Swap */
    for (j = 0; j < words; j += 2) {
        unsigned long a, b;

        a = p[j];
        b = p[j+1];
        p[j] = b;
        p[j+1] = a;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x373c2
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x37368
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/blocked.c
// Function: processUnblockedClients
void processUnblockedClients(void) {
    listNode *ln;
    client *c;

    while (listLength(server.unblocked_clients)) {
        ln = listFirst(server.unblocked_clients);
        serverAssert(ln != NULL);
        c = ln->value;
        listDelNode(server.unblocked_clients,ln);
        c->flags &= ~CLIENT_UNBLOCKED;
        /* Note that the client may be blocked again at this point, since
         * a new blocking command was processed. In that case we just remove
         * it from the unblocked clients list without actually processing
         * its pending query buffer. */
        if (!(c->flags & CLIENT_BLOCKED)) {
            c->btype = BLOCKED_NONE;

            /* Process remaining data in the input buffer. */
            if (c->querybuf && sdslen(c->querybuf) > 0) {
                processInputBuffer(c);
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x87439(%rip), %rax     # 0xbf0e8
movq 0x638(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x37d88
leaq 0x87420(%rip), %rax     # 0xbf0e8
movq 0x638(%rax), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x37cdf
jmp 0x37d01
leaq 0x6dabc(%rip), %rdi     # 0xa57a2
leaq 0x70c25(%rip), %rsi     # 0xa8912
movl $0x71, %edx
callq 0x300b0
movl $0x1, %edi
callq 0x12100
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
leaq 0x873d4(%rip), %rax     # 0xbf0e8
movq 0x638(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x12ec0
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x88(%rax)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x37d83
movq -0x10(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x37d81
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x37d90
cmpq $0x0, %rax
jbe 0x37d81
movq -0x10(%rbp), %rdi
callq 0x26330
jmp 0x37d83
jmp 0x37ca8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/blocked.c
// Function: unblockClient
void unblockClient(client *c) {
    /*if (c->btype == CLIENT_BLOCKED_JOB_REPL) {
        unblockClientWaitingJobRepl(c);
    } else if (c->btype == CLIENT_BLOCKED_QUEUES) {
        unblockClientBlockedForJobs(c);
    } else {
        serverPanic("Unknown btype in unblockClient().");
    }*/

    /* Clear the flags, and put the client in the unblocked list so that
     * we'll process new commands in its query buffer ASAP. */
    c->flags &= ~CLIENT_BLOCKED;
    c->btype = BLOCKED_NONE;
    server.bpop_blocked_clients--;
    /* The client may already be into the unblocked list because of a previous
     * blocking operation, don't add back it into the list multiple times. */
    if (!(c->flags & CLIENT_UNBLOCKED)) {
        c->flags |= CLIENT_UNBLOCKED;
        listAddNodeTail(server.unblocked_clients,c);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x90(%rax)
leaq 0x87294(%rip), %rax     # 0xbf0e8
movl 0x630(%rax), %ecx
addl $-0x1, %ecx
leaq 0x87284(%rip), %rax     # 0xbf0e8
movl %ecx, 0x630(%rax)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x37eab
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x88(%rax)
leaq 0x8724d(%rip), %rax     # 0xbf0e8
movq 0x638(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x12ce0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/sparkline.c
// Function: sparklineSequenceAddSample
void sparklineSequenceAddSample(struct sequence *seq, double value, char *label) {
    if (seq->length == 0) {
        seq->min = seq->max = value;
    } else {
        if (value < seq->min) seq->min = value;
        else if (value > seq->max) seq->max = value;
    }
    seq->samples = zrealloc(seq->samples,sizeof(struct sample)*(seq->length+1));
    seq->samples[seq->length].value = value;
    seq->samples[seq->length].label = label;
    seq->length++;
    if (label) seq->labels++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x38f47
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x38f8d
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x38f6b
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
jmp 0x38f8b
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x18(%rax), %xmm0
jbe 0x38f89
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
jmp 0x38f8b
jmp 0x38f8d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
callq 0x20b80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x39011
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterHistoryChange
long double counterHistoryChange(counter *cntr, mstime_t now, int history_last_index) {
    UNUSED(now);
    UNUSED(history_last_index);
    long double change = 0, last = cntr->myshard->value;

    /* Sum the difference of the last server.history_size+1 seconds:
     *
     * for (i = history_last_index; i >= 0; i--) {
     *     change += (last - cntr->history[i]);
     *     last    = cntr->history[i];
     * }
     * for (i = server.history_size - 1; i > history_last_index; i--) {
     *     change += (last - cntr->history[i]);
     *     last    = cntr->history[i];
     * }
     *
     * This is the same as:
     */
    change = last - cntr->history[server.history_index];

    return change;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
fldz
fstpt -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
fldt 0x30(%rax)
fstpt -0x40(%rbp)
fldt -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
leaq 0x85c44(%rip), %rcx     # 0xbf0e8
movslq 0x62c(%rcx), %rcx
shlq $0x4, %rcx
fldt (%rax,%rcx)
fsubrp %st, %st(1)
fstpt -0x30(%rbp)
fldt -0x30(%rbp)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterClearWantAcks
void counterClearWantAcks(counter *cntr) {
    if (cntr->want_acks == NULL) {
        cntr->want_acks = dictCreate(&clusterNodesDictType, NULL);
    } else {
        dictEmpty(cntr->want_acks, NULL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x39554
leaq 0x85802(%rip), %rdi     # 0xbed40
xorl %eax, %eax
movl %eax, %esi
callq 0x16120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x39565
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x17c70
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: dictCounterDestructor
void dictCounterDestructor(void *privdata, void *val) {
    DICT_NOTUSED(privdata);
    listNode *ln;
    listIter li;
    counter *cntr = val;
    pubsub *p;

    /* Unsubscribe everyone */
    /* pubsubUnsubscribeCounter will set cntr->subscribers to NULL */
    while (cntr->subscribers != NULL) {
        ln = listFirst(cntr->subscribers);
        p  = listNodeValue(ln);
        pubsubUnsubscribeCounter(p->c,cntr->name,1);
    }

    /* Free all shards */
    listRewind(cntr->shards,&li);
    while ((ln = listNext(&li)) != NULL) {
        shard *shrd = listNodeValue(ln);
        zfree(shrd);
    }

    listRelease(cntr->shards);
    if (cntr->want_acks) dictRelease(cntr->want_acks);

    /* cntr->name will be freed by the dict code. */

    zfree(cntr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x39678
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x3d900
jmp 0x39638
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13000
leaq -0x28(%rbp), %rdi
callq 0x13060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x396b3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x20ce0
jmp 0x39689
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x12b80
movq -0x30(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x396d8
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x16fe0
movq -0x30(%rbp), %rdi
callq 0x20ce0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterLookup
counter *counterLookup(const sds name) {
    dictEntry *de = dictFind(server.counters, name);
    if (de) {
        return dictGetVal(de);
    } else {
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x859e5(%rip), %rax     # 0xbf0e8
movq 0x618(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x17030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3972c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x39734
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterCreate
counter *counterCreate(const sds name) {
    counter *cntr = zcalloc(sizeof(counter) + (sizeof(long double) * server.history_size));
    cntr->name      = sdsdup(name);
    cntr->shards    = listCreate();
    cntr->history   = (long double*)(cntr + 1);
    cntr->precision = server.default_precision;

    serverAssert(dictAdd(server.counters, cntr->name, cntr) == DICT_OK);

    return cntr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x85995(%rip), %rax     # 0xbf0e8
movl 0x628(%rax), %eax
movl %eax, %edi
shlq $0x4, %rdi
addq $0x70, %rdi
callq 0x20ac0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1e300
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x12b00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq $0x70, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
leaq 0x85942(%rip), %rax     # 0xbf0e8
movsd 0x620(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x50(%rax)
leaq 0x8592a(%rip), %rax     # 0xbf0e8
movq 0x618(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x166b0
cmpl $0x0, %eax
jne 0x397dc
jmp 0x397fe
leaq 0x6fb12(%rip), %rdi     # 0xa92f5
leaq 0x6fb01(%rip), %rsi     # 0xa92eb
movl $0x8b, %edx
callq 0x300b0
movl $0x1, %edi
callq 0x12100
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterAddShard
shard *counterAddShard(counter *cntr, clusterNode* node, const char *node_name) {
    shard *shrd = zcalloc(sizeof(shard));
    shrd->node = node;
    memcpy(shrd->node_name,node_name,CLUSTER_NAMELEN);
    if (node == myself) {
        serverAssert(cntr->myshard == NULL);
        cntr->myshard = shrd;
    }
    listAddNodeTail(cntr->shards, shrd);
    return shrd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x70, %edi
callq 0x20ac0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
movl $0x28, %edx
callq 0x12500
movq -0x10(%rbp), %rax
leaq 0x99da2(%rip), %rcx     # 0xd3600
cmpq (%rcx), %rax
jne 0x3989e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x39870
jmp 0x39892
leaq 0x6fab4(%rip), %rdi     # 0xa932b
leaq 0x6fa6d(%rip), %rsi     # 0xa92eb
movl $0x96, %edx
callq 0x300b0
movl $0x1, %edi
callq 0x12100
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x12ce0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: countersUpdateValue
void countersUpdateValue(counter *cntr) {
    mstime_t now = mstime();
    long double elapsed;
    listNode *ln;
    listIter li;
    shard *shrd;

    cntr->value = 0;

    listRewind(cntr->shards,&li);
    while ((ln = listNext(&li)) != NULL) {
        shrd = listNodeValue(ln);

        /* Don't do a prediction with our own shard. */
        if (shrd == cntr->myshard) {
            cntr->value += shrd->value;
            continue;
        }

        elapsed = now - shrd->predict_time;
        shrd->value = shrd->predict_value + (elapsed * shrd->predict_change);

        /*if (shrd->node == NULL || nodeFailed(shrd->node)) {
            serverLog(LL_DEBUG,"Counter %s not updating shard of %.40s",
                cntr->name, shrd->node_name);
        } else if (shrd->predict_time > 0 && shrd->predict_value != 0) {
            serverLog(LL_DEBUG,"Counter %s new value %Lf for shard %.40s",
                cntr->name, shrd->value, shrd->node_name);
        } else {
            serverLog(LL_DEBUG,"Counter %s not using shard of %.40s %llu %Lf",
                cntr->name, shrd->node_name, shrd->predict_time, shrd->predict_value);
        }*/

        cntr->value += shrd->value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
callq 0x18e20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
fldz
fstpt 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13000
leaq -0x38(%rbp), %rdi
callq 0x13060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x399a6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x39961
movq -0x40(%rbp), %rax
fldt 0x30(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
faddp %st, %st(1)
fstpt 0x20(%rax)
jmp 0x3991f
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x48(%rbp)
fildll -0x48(%rbp)
fstpt -0x20(%rbp)
movq -0x40(%rbp), %rax
fldt 0x50(%rax)
fldt -0x20(%rbp)
fldt 0x60(%rax)
fmulp %st, %st(1)
faddp %st, %st(1)
fstpt 0x30(%rax)
movq -0x40(%rbp), %rax
fldt 0x30(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
faddp %st, %st(1)
fstpt 0x20(%rax)
jmp 0x3991f
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterPubSub
void counterPubSub(counter *cntr, mstime_t now) {
    listNode *ln;
    listIter li;

    if (cntr->subscribers == NULL)
        return;

    listRewind(cntr->subscribers,&li);
    while ((ln = listNext(&li)) != NULL) {
        pubsub *p = listNodeValue(ln);

        if (p->next > now) {
            continue;
        }
        countersUpdateValue(cntr);
        if (p->lastvalue == cntr->value) {
            continue;
        }

        addReply(p->c,shared.mbulkhdr[3]);
        addReply(p->c,shared.messagebulk);
        addReplyBulkCBuffer(p->c,cntr->name,sdslen(cntr->name));
        addReplyCounter(p->c, cntr);

        p->next      = now + p->seconds*1000;
        p->lastvalue = cntr->value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x399d0
jmp 0x39ad6
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13000
leaq -0x28(%rbp), %rdi
callq 0x13060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x39ad6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jle 0x39a14
jmp 0x399e1
movq -0x8(%rbp), %rdi
callq 0x398f0
movq -0x30(%rbp), %rax
fldt 0x20(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x39a39
jp 0x39a39
jmp 0x39a37
jmp 0x399e1
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x85db1(%rip), %rax     # 0xbf7f8
movq %rax, -0x48(%rbp)
movq 0x139e0(%rax), %rsi
callq 0x24050
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rdi
movq 0xf8(%rax), %rsi
callq 0x24050
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq %rdi, -0x38(%rbp)
callq 0x39ae0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x24ca0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x398c0
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
imulq $0x3e8, %rdx, %rdx      # imm = 0x3E8
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
movq -0x30(%rbp), %rax
fstpt 0x20(%rax)
jmp 0x399e1
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterResetShard
void counterResetShard(counter *cntr, clusterNode *node) {
    listNode *ln;
    listIter li;

    listRewind(cntr->shards,&li);
    while ((ln = listNext(&li)) != NULL) {
        shard *shrd = listNodeValue(ln);

        if (shrd->node == node) {
            cntr->value -= shrd->value;

            shrd->value = 0;
            if (shrd == cntr->myshard) {
                shrd->predict_time = 0;
            } else {
                shrd->predict_time = mstime();
            }
            shrd->predict_value = 0;
            shrd->predict_change = 0;

            server.dirty++;
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x13000
leaq -0x28(%rbp), %rdi
callq 0x13060
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x39c42
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x39c3d
movq -0x30(%rbp), %rax
fldt 0x30(%rax)
movq -0x8(%rbp), %rax
fldt 0x20(%rax)
fsubp %st, %st(1)
fstpt 0x20(%rax)
movq -0x30(%rbp), %rax
fldz
fstpt 0x30(%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x39bf9
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x39c09
callq 0x18e20
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x30(%rbp), %rax
fldz
fld %st(0)
fstpt 0x50(%rax)
movq -0x30(%rbp), %rax
fstpt 0x60(%rax)
leaq 0x854c6(%rip), %rax     # 0xbf0e8
movq 0x6a0(%rax), %rcx
addq $0x1, %rcx
leaq 0x854b4(%rip), %rax     # 0xbf0e8
movq %rcx, 0x6a0(%rax)
jmp 0x39c42
jmp 0x39b91
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterShardsForNode
int counterShardsForNode(clusterNode *node) {
    dictIterator *it;
    dictEntry *de;
    int count = 0;

    it = dictGetIterator(server.counters);
    while ((de = dictNext(it)) != NULL) {
        counter *cntr;
        listNode *ln;
        listIter li;
        shard *shrd;

        cntr = dictGetVal(de);

        listRewind(cntr->shards,&li);
        while ((ln = listNext(&li)) != NULL) {
            shrd = listNodeValue(ln);

            if (shrd->node == node) {
                count++;
            }
        }
    }
    dictReleaseIterator(it);

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x8547e(%rip), %rax     # 0xbf0e8
movq 0x618(%rax), %rdi
callq 0x17300
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x173a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x39ce3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x40(%rbp), %rsi
callq 0x13000
leaq -0x40(%rbp), %rdi
callq 0x13060
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x39ce1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x39cdf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39caa
jmp 0x39c7a
movq -0x10(%rbp), %rdi
callq 0x17510
movl -0x1c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterDeleteShards
void counterDeleteShards(clusterNode *node) {
    dictIterator *it;
    dictEntry *de;

    it = dictGetSafeIterator(server.counters);
    while ((de = dictNext(it)) != NULL) {
        counter *cntr;
        listIter li;
        listNode *ln;

        cntr = dictGetVal(de);

        listRewind(cntr->shards, &li);
        while ((ln = listNext(&li)) != NULL) {
            shard *shrd = listNodeValue(ln);
            if (shrd->node == node) {
                if (shrd == cntr->myshard) {
                    cntr->myshard = NULL;
                }
                listDelNode(cntr->shards, ln);
            }
        }
    }
    dictReleaseIterator(it);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x853d5(%rip), %rax     # 0xbf0e8
movq 0x618(%rax), %rdi
callq 0x17370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x173a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x39db1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13000
leaq -0x30(%rbp), %rdi
callq 0x13060
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x39dac
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x39daa
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x39d99
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x12ec0
jmp 0x39d53
jmp 0x39d23
movq -0x10(%rbp), %rdi
callq 0x17510
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: existsCommand
void existsCommand(client *c) {
    long long count = 0;
    int j;

    for (j = 1; j < c->argc; j++) {
        if (counterLookup(c->argv[j]->ptr) != NULL) count++;
    }
    addReplyLongLong(c,count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x39e1f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x396f0
cmpq $0x0, %rax
je 0x39e12
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x39e14
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x39ddb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x24ab0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: incrbyCommand
void incrbyCommand(client *c) {
    long double increment;
    if (getLongDoubleFromObjectOrReply(c,c->argv[2],&increment,NULL) != C_OK)
        return;
    genericIncrCommand(c, c->argv[1]->ptr, increment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a3f0
cmpl $0x0, %eax
je 0x3a030
jmp 0x3a04d
movq -0x8(%rbp), %rdi
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x39e40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: decrbyCommand
void decrbyCommand(client *c) {
    long double increment;
    if (getLongDoubleFromObjectOrReply(c,c->argv[2],&increment,NULL) != C_OK)
        return;
    genericIncrCommand(c, c->argv[1]->ptr, -increment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a3f0
cmpl $0x0, %eax
je 0x3a130
jmp 0x3a14f
movq -0x8(%rbp), %rdi
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
fldt -0x20(%rbp)
fchs
movq %rsp, %rax
fstpt (%rax)
callq 0x39e40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: mgetCommand
void mgetCommand(client *c) {
    counter *cntr;
    int j;

    addReplyMultiBulkLen(c,c->argc-1);
    for (j = 1; j < c->argc; j++) {
        cntr = counterLookup(c->argv[j]->ptr);

        if (cntr == NULL) {
            addReplyString(c,OBJ_SHARED_0STR,sizeof(OBJ_SHARED_0STR)-1);
        } else {
            addReplyCounter(c,cntr);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x24b20
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3a39a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x396f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a380
movq -0x8(%rbp), %rdi
leaq 0x6eff0(%rip), %rsi     # 0xa9364
movl $0x7, %edx
callq 0x24260
jmp 0x3a38d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x398c0
jmp 0x3a38f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a339
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: precisionCommand
void precisionCommand(client *c) {
    counter *cntr;
    double precision;

    cntr = counterLookup(c->argv[1]->ptr);
    if (cntr == NULL && c->argc == 2) {
        /* Counter doesn't exist, return the default precision. */
        addReplyDouble(c, server.default_precision);
        return;
    }

    if (c->argc == 2) {
        addReplyDouble(c, cntr->precision);
        return;
    }

    if (getDoubleFromObjectOrReply(c, c->argv[2], &precision, NULL) != C_OK)
        return;

    if (cntr == NULL) {
        cntr = counterCreate(c->argv[1]->ptr);
    }

    cntr->precision = precision;
    server.dirty++;
    addReplyDouble(c, cntr->precision);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x396f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a5f3
movq -0x8(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x3a5f3
movq -0x8(%rbp), %rdi
leaq 0x84b07(%rip), %rax     # 0xbf0e8
movsd 0x620(%rax), %xmm0
callq 0x24760
jmp 0x3a698
movq -0x8(%rbp), %rax
cmpl $0x2, 0x28(%rax)
jne 0x3a614
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm0
callq 0x24760
jmp 0x3a698
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a210
cmpl $0x0, %eax
je 0x3a638
jmp 0x3a698
cmpq $0x0, -0x10(%rbp)
jne 0x3a658
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x39740
movq %rax, -0x10(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x50(%rax)
leaq 0x84a7b(%rip), %rax     # 0xbf0e8
movq 0x6a0(%rax), %rcx
addq $0x1, %rcx
leaq 0x84a69(%rip), %rax     # 0xbf0e8
movq %rcx, 0x6a0(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x50(%rax), %xmm0
callq 0x24760
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: keysCommand
void keysCommand(client *c) {
    dictIterator *di;
    dictEntry *de;
    sds pattern = c->argv[1]->ptr;
    int plen = sdslen(pattern), allkeys;
    unsigned long numkeys = 0;
    void *replylen = addDeferredMultiBulkLength(c);

    di = dictGetSafeIterator(server.counters);
    allkeys = (pattern[0] == '*' && pattern[1] == '\0');
    while((de = dictNext(di)) != NULL) {
        sds key = dictGetKey(de);
        robj *keyobj;

        if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {
            keyobj = createStringObject(key,sdslen(key));
            addReplyBulk(c,keyobj);
            numkeys++;
            decrRefCount(keyobj);
        }
    }
    dictReleaseIterator(di);
    setDeferredMultiBulkLength(c,replylen,numkeys);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x39ae0
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24630
movq %rax, -0x38(%rbp)
leaq 0x84a00(%rip), %rax     # 0xbf0e8
movq 0x618(%rax), %rdi
callq 0x17370
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2a, %ecx
movb %al, -0x49(%rbp)
jne 0x3a71a
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x173a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3a7ce
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x3a786
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
callq 0x39ae0
movq -0x68(%rbp), %rdi
movl -0x5c(%rbp), %esi
movq -0x58(%rbp), %rdx
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x27c10
cmpl $0x0, %eax
je 0x3a7c9
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rdi
callq 0x39ae0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x292f0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x24c50
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
callq 0x296f0
jmp 0x3a725
movq -0x10(%rbp), %rdi
callq 0x17510
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x24680
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: mincrbyCommand
void mincrbyCommand(client *c) {
    int j;
    long double increment;

    if (getLongDoubleFromObjectOrReply(c,c->argv[1],&increment,NULL) != C_OK)
        return;

    addReplyMultiBulkLen(c,c->argc-2);
    for (j = 2; j < c->argc; j++) {
        genericIncrCommand(c, c->argv[j]->ptr, increment);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
leaq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a3f0
cmpl $0x0, %eax
je 0x3a820
jmp 0x3a875
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
subl $0x2, %eax
movslq %eax, %rsi
callq 0x24b20
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3a875
movq -0x8(%rbp), %rdi
movq 0x30(%rdi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
callq 0x39e40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a83d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: countersSync
void countersSync(clusterNode *node) {
    dictIterator *it;
    dictEntry *de;

    it = dictGetIterator(server.counters);
    while ((de = dictNext(it)) != NULL) {
        counter *cntr;
        listNode *ln;
        listIter li;
        shard *shrd;

        cntr = dictGetVal(de);

        /* If we have our own shard make sure to send it's prediction
         * to the new node. */
        if (cntr->myshard) {
            clusterSendShardToNode(cntr, node);
        }

        listRewind(cntr->shards,&li);
        while ((ln = listNext(&li)) != NULL) {
            shrd = listNodeValue(ln);

            if (memcmp(shrd->node_name, node->name, CLUSTER_NAMELEN) == 0) {
                shrd->node = node;
            }
        }
    }
    dictReleaseIterator(it);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x84855(%rip), %rax     # 0xbf0e8
movq 0x618(%rax), %rdi
callq 0x17300
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x173a0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x3a93b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3a8de
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x35a70
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13000
leaq -0x38(%rbp), %rdi
callq 0x13060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x3a936
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movl $0x28, %edx
callq 0x12420
cmpl $0x0, %eax
jne 0x3a934
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3a8ef
jmp 0x3a8a3
movq -0x10(%rbp), %rdi
callq 0x17510
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/counter.c
// Function: counterMaybeResend
void counterMaybeResend(counter *cntr) {
    clusterNode *node;
    int i;

    /* No acks to send? */
    if (cntr->want_acks == NULL || dictSize(cntr->want_acks) == 0) {
        return;
    }

    /* Too soon? */
    if (cntr->updated > mstime()-5000) {
        return;
    }

    /* Only check reachable nodes that have a valid link. */
    for (i = 0; i < server.cluster->reachable_nodes_count; i++) {
        node = server.cluster->reachable_nodes[i];

        if (node->link == NULL) continue;

        if (dictFind(cntr->want_acks, node->name) != NULL) {
            clusterSendShardToNode(cntr, node);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x3a985
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x40(%rcx), %rcx
addq 0x48(%rcx), %rax
cmpq $0x0, %rax
jne 0x3a98a
jmp 0x3aa2c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x18e20
movq %rax, %rcx
movq -0x20(%rbp), %rax
subq $0x1388, %rcx           # imm = 0x1388
cmpq %rcx, %rax
jle 0x3a9b0
jmp 0x3aa2c
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x84727(%rip), %rcx     # 0xbf0e8
movq 0x668(%rcx), %rcx
cmpl 0x38(%rcx), %eax
jge 0x3aa2c
leaq 0x84714(%rip), %rax     # 0xbf0e8
movq 0x668(%rax), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x3a9fb
jmp 0x3aa21
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x17030
cmpq $0x0, %rax
je 0x3aa1f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x35a70
jmp 0x3aa21
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3a9b7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbLoadLongLong
int ddbLoadLongLong(rio *ddb, long long* t) {
    int64_t t64;
    if (rioRead(ddb,&t64,8) == 0) return -1;
    *t = (long long)t64;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x3afa0
cmpq $0x0, %rax
jne 0x3b0e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b0f3
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbSaveRawString
ssize_t ddbSaveRawString(rio *ddb, unsigned char *s, size_t len) {
    ssize_t n, nwritten = 0;

    if ((n = ddbSaveLen(ddb,len)) == -1) return -1;
    nwritten += n;
    if (len > 0) {
        if (ddbWriteRaw(ddb,s,len) == -1) return -1;
        nwritten += len;
    }
    return nwritten;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x3b100
cltq
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
jne 0x3b1b1
movq $-0x1, -0x8(%rbp)
jmp 0x3b1f8
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x3b1f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3af10
cmpl $-0x1, %eax
jne 0x3b1e4
movq $-0x1, -0x8(%rbp)
jmp 0x3b1f8
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbLoadSds
sds ddbLoadSds(rio *ddb, sds s) {
    uint32_t len;

    len = ddbLoadLen(ddb);

    if (len == DDB_LENERR) {
        if (s) sdsfree(s);
        return NULL;
    }

    if (s == NULL) {
        s = sdsnewlen(NULL,len);
    } else {
        sdsclear(s);
        s = sdsgrowzero(s, len);
    }
    if (len && rioRead(ddb,s,len) == 0) {
        sdsfree(s);
        return NULL;
    }
    sdssetlen(s,len);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b130
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x3b24c
cmpq $0x0, -0x18(%rbp)
je 0x3b242
movq -0x18(%rbp), %rdi
callq 0x1e3c0
movq $0x0, -0x8(%rbp)
jmp 0x3b2c9
cmpq $0x0, -0x18(%rbp)
jne 0x3b267
movl -0x1c(%rbp), %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edi
callq 0x1dfe0
movq %rax, -0x18(%rbp)
jmp 0x3b282
movq -0x18(%rbp), %rdi
callq 0x1e4e0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x1ed40
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3b2b3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x3afa0
cmpq $0x0, %rax
jne 0x3b2b3
movq -0x18(%rbp), %rdi
callq 0x1e3c0
movq $0x0, -0x8(%rbp)
jmp 0x3b2c9
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3b2e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbSaveLongDouble
int ddbSaveLongDouble(rio *ddb, long double val) {
    unsigned char buf[128];
    int len;

    if (isnan(val)) {
        buf[0] = 253;
        len = 1;
    } else if (!isfinite(val)) {
        len = 1;
        buf[0] = (val < 0) ? 255 : 254;
    } else {
        snprintf((char*)buf+1,sizeof(buf)-1,"%.17Lg",val);
        buf[0] = strlen((char*)buf+1);
        len = buf[0]+1;
    }
    return ddbWriteRaw(ddb,buf,len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
fldt 0x10(%rbp)
movq %rdi, -0x8(%rbp)
fstpt -0x20(%rbp)
fldt -0x20(%rbp)
fucompi %st(0), %st
setp %al
testb $0x1, %al
jne 0x3b3a3
jmp 0x3b3b9
movb $-0x3, -0xa0(%rbp)
movl $0x1, -0xa4(%rbp)
jmp 0x3b46b
fldt -0x20(%rbp)
fstpt -0xb0(%rbp)
movq -0xb0(%rbp), %rax
shrq $0x3f, %rax
movb %al, %dl
movzwl -0xa8(%rbp), %eax
andl $0x7fff, %eax           # imm = 0x7FFF
movl %eax, %ecx
decl %ecx
movzwl %cx, %ecx
subl $0x7ffe, %ecx           # imm = 0x7FFE
setb %cl
andb %dl, %cl
testq %rax, %rax
sete %al
orb %cl, %al
testb $0x1, %al
jne 0x3b421
xorl %eax, %eax
movl $0x1, -0xa4(%rbp)
fldt -0x20(%rbp)
fldz
fucompi %st(1), %st
fstp %st(0)
seta %al
movzbl %al, %eax
orl $0xfe, %eax
movb %al, -0xa0(%rbp)
jmp 0x3b469
leaq -0x9f(%rbp), %rdi
fldt -0x20(%rbp)
movq %rsp, %rax
fstpt (%rax)
leaq 0x6a315(%rip), %rdx     # 0xa574c
xorl %eax, %eax
movl $0x7f, %esi
callq 0x122c0
leaq -0xa0(%rbp), %rdi
addq $0x1, %rdi
callq 0x12230
movb %al, -0xa0(%rbp)
movzbl -0xa0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x3b46b
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movslq -0xa4(%rbp), %rdx
callq 0x3af10
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)