LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x3cfd4(%rip), %rax     # 0x6f088
movq 0x618(%rax), %rdi
callq 0x19242
movq %rax, %r14
movq %rax, %rdi
callq 0x1929d
testq %rax, %rax
je 0x32133
leaq 0x8(%rsp), %r15
movq 0x8(%rax), %r12
cmpq $0x0, 0x10(%r12)
je 0x320ec
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2eace
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x16c72
movq %r15, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x32126
movq 0x10(%rax), %r12
leaq 0x8(%r12), %rdi
movl $0x28, %edx
movq %rbx, %rsi
callq 0x12620
testl %eax, %eax
jne 0x320f9
movq %rbx, (%r12)
jmp 0x320f9
movq %r14, %rdi
callq 0x1929d
testq %rax, %rax
jne 0x320d5
movq %r14, %rdi
callq 0x1935a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x321e0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
je 0x321d5
movq %rdi, %rbx
movq 0x48(%rdi), %r14
callq 0x1a1d3
addq $-0x1388, %rax          # imm = 0xEC78
cmpq %rax, %r14
jg 0x321d5
leaq 0x3cf04(%rip), %r15     # 0x6f088
movq 0x668(%r15), %rax
cmpl $0x0, 0x38(%rax)
jle 0x321d5
xorl %r12d, %r12d
movq 0x30(%rax), %rax
movq (%rax,%r12,8), %r14
cmpq $0x0, 0x88(%r14)
je 0x321c2
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x190de
testq %rax, %rax
je 0x321c2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2eace
incq %r12
movq 0x668(%r15), %rax
movslq 0x38(%rax), %rcx
cmpq %rcx, %r12
jl 0x32194
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/counter.c
// Function: countersCleanupCron
void countersCleanupCron(void) {
    dictIterator *it;
    dictEntry *de;
    mstime_t notafter = mstime() - 2000; /* Don't delete counters that changed in the last N milliseconds. */

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

        cntr = dictGetVal(de);

        // Don't delete counters that might haven't synced yet.
        if (cntr->want_acks != NULL && dictSize(cntr->want_acks) > 0) {
            continue;
        }

        listRewind(cntr->shards, &li);
        while ((ln = listNext(&li)) != NULL) {
            shard *shrd = listNodeValue(ln);
            if (shrd->predict_time == 0 || shrd->predict_time > notafter) {
                continue;
            }
            if (shrd->value == 0 && shrd->predict_value == 0 && shrd->predict_change == 0) {
                if (shrd == cntr->myshard) {
                    cntr->myshard = NULL;
                }
                listDelNode(cntr->shards, ln);
            }
        }

        if (listLength(cntr->shards) == 0) {
            /* Don't delete counters that have subscribers as they keep
             * a pointer to the counter.
             */
            if (cntr->subscribers == NULL) {
                dictDelete(server.counters, cntr->name);
            }
        }
    }
    dictReleaseIterator(it);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
callq 0x1a1d3
movq %rax, %rbx
leaq 0x3cc79(%rip), %r12     # 0x6f088
movq 0x618(%r12), %rdi
callq 0x1926c
movq %rax, %r14
movq %rax, %rdi
callq 0x1929d
testq %rax, %rax
je 0x324fd
addq $-0x7d0, %rbx           # imm = 0xF830
movq %rsp, %r15
movq 0x8(%rax), %r13
movq 0x40(%r13), %rax
testq %rax, %rax
je 0x32455
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
jne 0x324ec
movq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x16c72
movq %r15, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x324c9
movq 0x10(%rax), %rcx
movq 0x40(%rcx), %rdx
testq %rdx, %rdx
je 0x32461
cmpq %rbx, %rdx
jg 0x32461
fldt 0x30(%rcx)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x32461
jp 0x32461
fldt 0x50(%rcx)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x32461
jp 0x32461
fldt 0x60(%rcx)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x32461
jp 0x32461
cmpq 0x10(%r13), %rcx
jne 0x324bb
movq $0x0, 0x10(%r13)
movq 0x8(%r13), %rdi
movq %rax, %rsi
callq 0x16be4
jmp 0x32461
movq 0x8(%r13), %rax
cmpq $0x0, 0x28(%rax)
jne 0x324ec
cmpq $0x0, 0x60(%r13)
jne 0x324ec
movq 0x618(%r12), %rdi
movq (%r13), %rsi
callq 0x18e09
movq %r14, %rdi
callq 0x1929d
testq %rax, %rax
jne 0x3243a
movq %r14, %rdi
callq 0x1935a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x8, %eax
movq %rsp, %r15
testq %rax, %rax
je 0x326ff
movq %rax, %rbp
movq 0x38(%r14), %rax
cmpq %rbp, %rax
movq %rbp, %r12
cmovbq %rax, %r12
testq %rax, %rax
cmoveq %rbp, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r14)
movq %rax, %r13
testq %rax, %rax
je 0x326ed
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x326de
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
addq %r12, %r15
movq %rbp, %rax
subq %r12, %rax
addq %r12, 0x30(%r14)
jmp 0x326f0
movq %rbp, %rax
testq %r13, %r13
jne 0x32699
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbp, %rbp
jne 0x32708
movq (%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x4(%rsp), %rsi
movl %ebx, (%rsi)
movl $0x4, %edx
callq 0x3254f
cmpl $-0x1, %eax
je 0x3280c
movslq %eax, %r14
testq %rbx, %rbx
je 0x32813
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3254f
addq %rbx, %r14
cmpl $-0x1, %eax
movq $-0x1, %rax
cmoveq %rax, %r14
jmp 0x32813
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3272e
cmpl $-0x1, %eax
je 0x32864
movl %eax, %ebp
movl %eax, %r14d
testq %rbx, %rbx
movq %r14, 0x10(%rsp)
je 0x32875
movq %rbx, %rdi
callq 0x1df40
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e59e
jmp 0x3287f
testq %rbx, %rbx
je 0x32901
movq %rbx, %rdi
jmp 0x328fc
xorl %edi, %edi
movq %r14, %rsi
callq 0x1dd2c
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
je 0x32912
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x32912
movq %rax, %rbx
movq 0x38(%r15), %rax
cmpq %rbx, %rax
movq %rbx, %r13
cmovbq %rax, %r13
testq %rax, %rax
cmoveq %rbx, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *(%r15)
movq %rax, %r14
testq %rax, %rax
je 0x328ea
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x328db
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *%rax
addq %r13, %r12
movq %rbx, %rax
subq %r13, %rax
addq %r13, 0x30(%r15)
jmp 0x328ed
movq %rbx, %rax
testq %r14, %r14
jne 0x32896
testq %rbx, %rbx
je 0x32912
movq 0x8(%rsp), %rdi
callq 0x1ded3
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movzbl -0x1(%rax), %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x32903
leaq 0x2612e(%rip), %rcx     # 0x58a58
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
shlb $0x3, %bpl
movb %bpl, -0x1(%rax)
jmp 0x32903
movq 0x10(%rsp), %rcx
movq %rcx, -0x11(%rax)
jmp 0x32903
movw %bp, -0x5(%rax)
jmp 0x32903
movl %ebp, -0x9(%rax)
jmp 0x32903
movb %bpl, -0x3(%rax)
jmp 0x32903
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
fldt 0xc0(%rsp)
fucomi %st(0), %st
jp 0x32a08
fld %st(0)
fstpt 0x10(%rsp)
movq 0x10(%rsp), %rax
shrq $0x3f, %rax
movzwl 0x18(%rsp), %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
leal -0x1(%rcx), %edx
movzwl %dx, %edx
cmpl $0x7ffe, %edx           # imm = 0x7FFE
setb %dl
andb %al, %dl
testq %rcx, %rcx
sete %al
orb %dl, %al
jne 0x329c0
fldz
fucompi %st(1), %st
fstp %st(0)
seta %al
orb $-0x2, %al
movb %al, 0x20(%rsp)
movl $0x1, %edx
jmp 0x329f0
leaq 0x21(%rsp), %r14
fstpt (%rsp)
leaq 0x22295(%rip), %rdx     # 0x54c64
movl $0x7f, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x122d0
movq %r14, %rdi
callq 0x12250
movb %al, -0x1(%r14)
movzbl %al, %edx
incq %rdx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3254f
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
fstp %st(0)
movb $-0x3, 0x20(%rsp)
jmp 0x329b9
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbLoadLongDouble
int ddbLoadLongDouble(rio *ddb, long double *val) {
    char buf[256];
    unsigned char len;

    if (rioRead(ddb,&len,1) == 0) return -1;
    switch(len) {
    case 255: *val = R_NegInf; return 0;
    case 254: *val = R_PosInf; return 0;
    case 253: *val = R_Nan; return 0;
    default:
        if (rioRead(ddb,buf,len) == 0) return -1;
        buf[len] = '\0';
        sscanf(buf, "%Lg", val);
        if (*val > COUNTER_MAX || *val < COUNTER_MIN) {
            *val = 0;
        }
        return 0;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movl $0x1, %eax
leaq 0x7(%rsp), %r15
testq %rax, %rax
fldz
je 0x32aa0
movq %rax, %rbx
fstp %st(0)
movq 0x38(%r14), %rax
cmpq %rbx, %rax
movq %rbx, %r12
cmovbq %rax, %r12
testq %rax, %rax
cmoveq %rbx, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r14)
movq %rax, %r13
testq %rax, %rax
je 0x32a8c
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x32a7d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
addq %r12, %r15
movq %rbx, %rax
subq %r12, %rax
addq %r12, 0x30(%r14)
jmp 0x32a8f
movq %rbx, %rax
testq %r13, %r13
jne 0x32a34
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rbx, %rbx
fldz
jne 0x32ae2
fstp %st(0)
movzbl 0x7(%rsp), %eax
cmpl $0xfd, %eax
je 0x32ace
cmpl $0xfe, %eax
je 0x32ac5
cmpl $0xff, %eax
jne 0x32af8
leaq 0x508ad(%rip), %rax     # 0x83370
jmp 0x32ad5
leaq 0x5089c(%rip), %rax     # 0x83368
jmp 0x32ad5
leaq 0x508a3(%rip), %rax     # 0x83378
fldl (%rax)
movq 0x8(%rsp), %rax
fstpt (%rax)
xorl %ebp, %ebp
fldz
fstp %st(0)
movl %ebp, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r15
testq %rax, %rax
fldz
je 0x32b6d
movq %rax, %rbx
fstp %st(0)
movq 0x38(%r14), %rax
cmpq %rbx, %rax
movq %rbx, %r12
cmovbq %rax, %r12
testq %rax, %rax
cmoveq %rbx, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r14)
movq %rax, %r13
testq %rax, %rax
je 0x32b55
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x32b46
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
addq %r12, %r15
movq %rbx, %rax
subq %r12, %rax
addq %r12, 0x30(%r14)
jmp 0x32b58
movq %rbx, %rax
testq %r13, %r13
jne 0x32afd
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rbx, %rbx
fldz
jne 0x32ae2
fstp %st(0)
movzbl 0x7(%rsp), %eax
movb $0x0, 0x10(%rsp,%rax)
leaq 0x25f68(%rip), %rsi     # 0x58ae8
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x125f0
fldt (%rbx)
fabs
fldz
fldl 0x25d46(%rip)           # 0x588e8
fxch %st(2)
fucompi %st(2), %st
fstp %st(1)
jbe 0x32ae2
jmp 0x32ad7
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ddb.c
// Function: startLoading
void startLoading(FILE *fp) {
    struct stat sb;

    /* Load the DB */
    server.loading = 1;
    server.loading_start_time = time(NULL);
    server.loading_loaded_bytes = 0;
    if (fstat(fileno(fp), &sb) == -1) {
        server.loading_total_bytes = 0;
    } else {
        server.loading_total_bytes = sb.st_size;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x3ba94(%rip), %r14     # 0x6f088
movl $0x1, 0x320(%r14)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x12550
movq %rax, 0x338(%r14)
movq %r15, 0x330(%r14)
movq %rbx, %rdi
callq 0x12560
movq %rsp, %rsi
movl %eax, %edi
callq 0x128a0
cmpl $-0x1, %eax
je 0x33633
movq 0x30(%rsp), %r15
movq %r15, 0x328(%r14)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbLoadProgressCallback
void ddbLoadProgressCallback(rio *r, const void *buf, size_t len) {
    if (server.ddb_checksum)
        rioGenericUpdateChecksum(r, buf, len);
    if (server.loading_process_events_interval_bytes &&
        (r->processed_bytes + len)/server.loading_process_events_interval_bytes > r->processed_bytes/server.loading_process_events_interval_bytes)
    {
        /* The DB can take some non trivial amount of time to load. Update
         * our cached time since it is used to create and update the last
         * interaction time with clients and for other important things. */
        updateCachedTime();
        loadingProgress(r->processed_bytes);
        processEventsWhileBlocked();
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x3b9e6(%rip), %r15     # 0x6f088
cmpl $0x0, 0x6d4(%r15)
je 0x336b7
movq %rbx, %rdi
movq %r14, %rdx
callq 0x33c69
movq 0x340(%r15), %rdi
testq %rdi, %rdi
je 0x336fa
movq 0x30(%rbx), %rcx
addq %rcx, %r14
movq %r14, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %rsi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rax, %rsi
jbe 0x336fa
callq 0x1a99d
movq 0x30(%rbx), %rdi
callq 0x33647
popq %rbx
popq %r14
popq %r15
jmp 0x24daa
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ddb.c
// Function: backgroundSaveDoneHandlerDisk
void backgroundSaveDoneHandlerDisk(int exitcode, int bysignal) {
    if (!bysignal && exitcode == 0) {
        serverLog(LL_NOTICE,
            "Background saving terminated with success");
        server.dirty = server.dirty - server.dirty_before_bgsave;
        server.lastsave = time(NULL);
        server.lastbgsave_status = C_OK;
    } else if (!bysignal && exitcode != 0) {
        serverLog(LL_WARNING, "Background saving error");
        server.lastbgsave_status = C_ERR;
    } else {
        mstime_t latency;

        serverLog(LL_WARNING,
            "Background saving terminated by signal %d", bysignal);
        latencyStartMonitor(latency);
        ddbRemoveTempFile(server.ddb_child_pid);
        latencyEndMonitor(latency);
        latencyAddSampleIfNeeded("ddb-unlink-temp-file",latency);
        /* SIGUSR1 is whitelisted, so we have a way to kill a child without
         * tirggering an error conditon. */
        if (bysignal != SIGUSR1)
            server.lastbgsave_status = C_ERR;
    }
    server.ddb_child_pid = -1;
    server.ddb_child_type = DDB_CHILD_TYPE_NONE;
    server.ddb_save_time_last = time(NULL)-server.ddb_save_time_start;
    server.ddb_save_time_start = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %eax
orl %edi, %eax
je 0x3395e
movl %esi, %ebx
testl %esi, %esi
setne %al
testl %edi, %edi
sete %cl
orb %al, %cl
jne 0x3399c
leaq 0x253b4(%rip), %rsi     # 0x58cfb
movl $0x3, %edi
xorl %eax, %eax
callq 0x19fb1
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x33a3f
leaq 0x2536c(%rip), %rsi     # 0x58cd1
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x19fb1
leaq 0x3b70d(%rip), %rbx     # 0x6f088
movq 0x6a8(%rbx), %rax
subq %rax, 0x6a0(%rbx)
xorl %edi, %edi
callq 0x12550
movq %rax, 0x6d8(%rbx)
jmp 0x33a3f
leaq 0x25370(%rip), %rsi     # 0x58d13
xorl %r14d, %r14d
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x19fb1
leaq 0x3b6cd(%rip), %r12     # 0x6f088
cmpq $0x0, 0x670(%r12)
je 0x339ce
callq 0x1a1d3
movq %rax, %r14
movl 0x6b0(%r12), %ecx
leaq 0x2511a(%rip), %rdx     # 0x58af7
movq %rsp, %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0x122d0
movq %r15, %rdi
callq 0x120f0
cmpq $0x0, 0x670(%r12)
je 0x33a0d
callq 0x1a1d3
subq %r14, %rax
movq %rax, %r14
movq 0x670(%r12), %rax
testq %rax, %rax
sete %cl
cmpq %rax, %r14
setl %al
orb %cl, %al
jne 0x33a34
leaq 0x248a1(%rip), %rdi     # 0x582cd
movq %r14, %rsi
callq 0x30346
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0xa, %ebx
je 0x33a4d
leaq 0x3b642(%rip), %rax     # 0x6f088
movl %r14d, 0x6fc(%rax)
leaq 0x3b634(%rip), %rbx     # 0x6f088
movl $0xffffffff, 0x6b0(%rbx) # imm = 0xFFFFFFFF
movl $0x0, 0x6f8(%rbx)
xorl %edi, %edi
callq 0x12550
subq 0x6f0(%rbx), %rax
movq %rax, 0x6e8(%rbx)
movq $-0x1, 0x6f0(%rbx)
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ddb.c
// Function: saveCommand
void saveCommand(client *c) {
    if (server.ddb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
        return;
    }
    if (ddbSave(server.ddb_filename) == C_OK) {
        addReply(c,shared.ok);
    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3b5ae(%rip), %rax     # 0x6f088
cmpl $-0x1, 0x6b0(%rax)
je 0x33af3
leaq 0x25273(%rip), %rsi     # 0x58d5d
movq %rbx, %rdi
popq %rbx
jmp 0x2230a
movq 0x6c8(%rax), %rdi
callq 0x3300c
testl %eax, %eax
je 0x33b10
leaq 0x3bc8e(%rip), %rax     # 0x6f798
movq 0x10(%rax), %rsi
jmp 0x33b1b
leaq 0x3bc81(%rip), %rax     # 0x6f798
movq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x21f58
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/ddb.c
// Function: bgsaveCommand
void bgsaveCommand(client *c) {
    if (server.ddb_child_pid != -1) {
        addReplyError(c,"Background save already in progress");
    } else if (ddbSaveBackground(server.ddb_filename) == C_OK) {
        addReplyStatus(c,"Background saving started");
    } else {
        addReply(c,shared.err);
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3b559(%rip), %rax     # 0x6f088
cmpl $-0x1, 0x6b0(%rax)
je 0x33b48
leaq 0x2521e(%rip), %rsi     # 0x58d5d
movq %rbx, %rdi
popq %rbx
jmp 0x2230a
movq 0x6c8(%rax), %rdi
callq 0x331b8
testl %eax, %eax
je 0x33b6c
leaq 0x3bc39(%rip), %rax     # 0x6f798
movq 0x10(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x21f58
leaq 0x2520e(%rip), %rsi     # 0x58d81
movq %rbx, %rdi
popq %rbx
jmp 0x224d1
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/rio.c
// Function: rioInitWithFile
void rioInitWithFile(rio *r, FILE *fp) {
    *r = rioFileIO;
    r->io.file.fp = fp;
    r->io.file.buffered = 0;
    r->io.file.autosync = 0;
}

// Assembly:
movq %rsi, %rax
movq %rdi, %rdx
leaq 0x3878d(%rip), %rsi     # 0x6c338
movl $0xd, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq %rax, 0x40(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/rio.c
// Function: rioInitWithFdset
void rioInitWithFdset(rio *r, int *fds, int numfds) {
    int j;

    *r = rioFdsetIO;
    r->io.fdset.fds = zmalloc(sizeof(int)*numfds);
    r->io.fdset.state = zmalloc(sizeof(int)*numfds);
    memcpy(r->io.fdset.fds,fds,sizeof(int)*numfds);
    for (j = 0; j < numfds; j++) r->io.fdset.state[j] = 0;
    r->io.fdset.numfds = numfds;
    r->io.fdset.pos = 0;
    r->io.fdset.buf = sdsempty();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x387ca(%rip), %rsi     # 0x6c3a0
movl $0xd, %ecx
rep  movsq (%rsi), %es:(%rdi)
movslq %edx, %r12
leaq (,%r12,4), %r15
movq %r15, %rdi
callq 0x1fea5
movq %rax, 0x40(%rbx)
movq %r15, %rdi
callq 0x1fea5
movq %rax, 0x48(%rbx)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x12520
testl %r12d, %r12d
jle 0x33c2c
movl %ebp, %eax
xorl %ecx, %ecx
movq 0x48(%rbx), %rdx
movl $0x0, (%rdx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x33c19
movl %ebp, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
callq 0x1de3f
movq %rax, 0x60(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/rio.c
// Function: rioWriteBulkCount
size_t rioWriteBulkCount(rio *r, char prefix, int count) {
    char cbuf[128];
    int clen;

    cbuf[0] = prefix;
    clen = 1+ll2string(cbuf+1,sizeof(cbuf)-1,count);
    cbuf[clen++] = '\r';
    cbuf[clen++] = '\n';
    if (rioWrite(r,cbuf,clen) == 0) return 0;
    return clen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x1(%rsp), %rdi
movb %sil, -0x1(%rdi)
movslq %edx, %rdx
movl $0x7f, %esi
callq 0x2535e
cltq
movq %rsp, %r15
movw $0xa0d, 0x1(%rax,%r15)  # imm = 0xA0D
addl $0x3, %eax
movslq %eax, %r14
movq %r14, %r13
testq %r13, %r13
je 0x33d40
movq 0x20(%rbx), %rax
movq 0x38(%rbx), %rcx
cmpq %r13, %rcx
movq %r13, %r12
cmovbq %rcx, %r12
testq %rcx, %rcx
cmoveq %r13, %r12
testq %rax, %rax
je 0x33d1d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x8(%rbx)
testq %rax, %rax
je 0x33d38
addq %r12, %r15
subq %r12, %r13
addq %r12, 0x30(%rbx)
testq %rax, %rax
jne 0x33cef
xorl %r14d, %r14d
movq %r14, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/rio.c
// Function: rioWriteBulkString
size_t rioWriteBulkString(rio *r, const char *buf, size_t len) {
    size_t nwritten;

    if ((nwritten = rioWriteBulkCount(r,'$',len)) == 0) return 0;
    if (len > 0 && rioWrite(r,buf,len) == 0) return 0;
    if (rioWrite(r,"\r\n",2) == 0) return 0;
    return nwritten+len+2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0x24, %esi
callq 0x33cb0
testq %rax, %rax
je 0x33e50
movq %rax, %r15
testq %rbx, %rbx
je 0x33de5
movq %rbx, %rcx
testq %rcx, %rcx
je 0x33de5
movq %rcx, %rbp
movq 0x20(%r14), %rax
movq 0x38(%r14), %rcx
cmpq %rbp, %rcx
movq %rbp, %r13
cmovbq %rcx, %r13
testq %rcx, %rcx
cmoveq %rbp, %r13
testq %rax, %rax
je 0x33db7
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *%rax
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x8(%r14)
testq %rax, %rax
je 0x33dd8
addq %r13, %r12
movq %rbp, %rcx
subq %r13, %rcx
addq %r13, 0x30(%r14)
jmp 0x33ddb
movq %rbp, %rcx
testq %rax, %rax
jne 0x33d86
testq %rbp, %rbp
jne 0x33e50
movl $0x2, %ecx
leaq 0x217ba(%rip), %r12     # 0x555ab
testq %rcx, %rcx
je 0x33e54
movq %rcx, %rbp
movq 0x20(%r14), %rax
movq 0x38(%r14), %rcx
cmpq %rbp, %rcx
movq %rbp, %r13
cmovbq %rcx, %r13
testq %rcx, %rcx
cmoveq %rbp, %r13
testq %rax, %rax
je 0x33e22
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *%rax
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x8(%r14)
testq %rax, %rax
je 0x33e43
addq %r13, %r12
movq %rbp, %rcx
subq %r13, %rcx
addq %r13, 0x30(%r14)
jmp 0x33e46
movq %rbp, %rcx
testq %rax, %rax
jne 0x33df1
testq %rbp, %rbp
je 0x33e54
xorl %eax, %eax
jmp 0x33e5c
leaq (%rbx,%r15), %rax
addq $0x2, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/rio.c
// Function: rioBufferRead
static size_t rioBufferRead(rio *r, void *buf, size_t len) {
    if (sdslen(r->io.buffer.ptr)-r->io.buffer.pos < len)
        return 0; /* not enough buffer to return len bytes. */
    memcpy(buf,r->io.buffer.ptr+r->io.buffer.pos,len);
    r->io.buffer.pos += len;
    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rax
movzbl -0x1(%rax), %ecx
movl %ecx, %edx
andl $0x7, %edx
cmpl $0x4, %edx
ja 0x33f23
leaq 0x24e9e(%rip), %rdi     # 0x58d9c
movslq (%rdi,%rdx,4), %rdx
addq %rdi, %rdx
jmpq *%rdx
shrl $0x3, %ecx
jmp 0x33f25
movq -0x11(%rax), %rcx
jmp 0x33f25
movzwl -0x5(%rax), %ecx
jmp 0x33f25
movl -0x9(%rax), %ecx
jmp 0x33f25
movzbl -0x3(%rax), %ecx
jmp 0x33f25
xorl %ecx, %ecx
movq 0x48(%r14), %rdx
subq %rdx, %rcx
cmpq %rbx, %rcx
jae 0x33f35
xorl %eax, %eax
jmp 0x33f4f
addq %rdx, %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x12520
addq %rbx, 0x48(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/rio.c
// Function: rioFileWrite
static size_t rioFileWrite(rio *r, const void *buf, size_t len) {
    size_t retval;

    retval = fwrite(buf,len,1,r->io.file.fp);
    r->io.file.buffered += len;

    if (r->io.file.autosync &&
        r->io.file.buffered >= r->io.file.autosync)
    {
        fflush(r->io.file.fp);
        aof_fsync(fileno(r->io.file.fp));
        r->io.file.buffered = 0;
    }
    return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
movq 0x40(%rdi), %rcx
movl $0x1, %edx
movq %rsi, %rdi
movq %r15, %rsi
callq 0x12890
movq %rax, %r14
movq 0x50(%rbx), %rax
addq 0x48(%rbx), %r15
movq %r15, 0x48(%rbx)
testq %rax, %rax
sete %cl
cmpq %rax, %r15
setl %al
orb %cl, %al
jne 0x34000
movq 0x40(%rbx), %rdi
callq 0x125e0
movq 0x40(%rbx), %rdi
callq 0x12560
movl %eax, %edi
callq 0x120e0
movq $0x0, 0x48(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/pubsub.c
// Function: pubsubSubscribeCounter
int pubsubSubscribeCounter(client *c, sds name, long long seconds) {
    int retval = 0;
    counter* cntr;
    pubsub* p;

    cntr = counterLookup(name);
    if (cntr == NULL) {
        cntr = counterCreate(name);
    }

    if (c->sub_counters == NULL) {
        c->sub_counters = dictCreate(&counterLookupDictType,NULL);
    }

    /* Add the counter to the client -> counters hash table */
    if (dictAdd(c->sub_counters,cntr->name,cntr) == DICT_OK) {
        retval = 1;
        if (cntr->subscribers == NULL) {
            cntr->subscribers = listCreate();
        }
        p = zmalloc(sizeof(pubsub));
        p->c         = c;
        p->seconds   = seconds;
        p->next      = 0;
        p->lastvalue = 0;
        serverAssert(listAddNodeTail(cntr->subscribers,p) != NULL);
    }
    /* Notify the client */
    addReply(c,shared.mbulkhdr[3]);
    addReply(c,shared.subscribebulk);
    addReplyBulkCBuffer(c,name,sdslen(name));
    addReplyLongLong(c,dictSize(c->sub_counters));
    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x31327
movq %rax, %r12
testq %rax, %rax
jne 0x3423c
movq %r14, %rdi
callq 0x3134d
movq %rax, %r12
cmpq $0x0, 0xa8(%rbx)
jne 0x3425b
leaq 0x3ab83(%rip), %rdi     # 0x6edd0
xorl %esi, %esi
callq 0x18875
movq %rax, 0xa8(%rbx)
movq 0xa8(%rbx), %rdi
movq (%r12), %rsi
movq %r12, %rdx
callq 0x18b97
xorl %ebp, %ebp
testl %eax, %eax
jne 0x342bf
cmpq $0x0, 0x60(%r12)
jne 0x34286
callq 0x16a2c
movq %rax, 0x60(%r12)
movl $0x30, %edi
callq 0x1fea5
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
movq $0x0, 0x10(%rax)
fldz
fstpt 0x20(%rax)
movq 0x60(%r12), %rdi
movq %rax, %rsi
callq 0x16aff
movl $0x1, %ebp
testq %rax, %rax
je 0x34351
leaq 0x3b4d2(%rip), %r15     # 0x6f798
movq 0x139e0(%r15), %rsi
movq %rbx, %rdi
callq 0x21f58
movq 0x108(%r15), %rsi
movq %rbx, %rdi
callq 0x21f58
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x34322
leaq 0x24afe(%rip), %rcx     # 0x58df8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x34324
movq -0x11(%r14), %rdx
jmp 0x34324
movzwl -0x5(%r14), %edx
jmp 0x34324
movl -0x9(%r14), %edx
jmp 0x34324
movzbl -0x3(%r14), %edx
jmp 0x34324
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22a7d
movq 0xa8(%rbx), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x22941
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24ac8(%rip), %rdi     # 0x58e20
leaq 0x24aee(%rip), %rsi     # 0x58e4d
movl $0x41, %edx
callq 0x2a9ff
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/pubsub.c
// Function: pubsubUnsubscribeCounter
int pubsubUnsubscribeCounter(client *c, sds name, int notify) {
    dictEntry *de;
    listIter li;
    listNode *ln;
    int retval = 0;
    counter *cntr;

    /* Remove the counter from the client -> counters hash table */
    if (c->sub_counters != NULL) {
        de = dictUnlink(c->sub_counters,name);
        if (de != NULL) {
            retval = 1;
            cntr = dictGetVal(de);
            dictFreeUnlinkedEntry(c->sub_counters,de);

            listRewind(cntr->subscribers,&li);
            while ((ln = listNext(&li)) != NULL) {
                pubsub *p = listNodeValue(ln);
                if (p->c == c) {
                    listDelNode(cntr->subscribers,ln);
                    zfree(p);
                    break;
                }
            }
            if (listLength(cntr->subscribers) == 0) {
                listRelease(cntr->subscribers);
                cntr->subscribers = NULL;
            }
        }
    }
    /* Notify the client */
    if (notify) {
        addReply(c,shared.mbulkhdr[3]);
        addReply(c,shared.unsubscribebulk);
        addReplyBulkCBuffer(c,name,sdslen(name));
        addReplyLongLong(c,dictSize(c->sub_counters));
    }
    return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
xorl %r12d, %r12d
testq %rdi, %rdi
je 0x34413
movq %r14, %rsi
callq 0x18fa5
testq %rax, %rax
je 0x34413
movq 0x8(%rax), %rbp
movq 0xa8(%rbx), %rdi
movq %rax, %rsi
callq 0x18faf
movq 0x60(%rbp), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x16c72
movq %r12, %rdi
callq 0x16c8f
testq %rax, %rax
je 0x343f5
movq 0x10(%rax), %r13
cmpq %rbx, (%r13)
jne 0x343ca
movq 0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x16be4
movq %r13, %rdi
callq 0x1ffff
movq 0x60(%rbp), %rdi
movl $0x1, %r12d
cmpq $0x0, 0x28(%rdi)
jne 0x34413
callq 0x16a50
movq $0x0, 0x60(%rbp)
testl %r15d, %r15d
je 0x344a3
leaq 0x3b375(%rip), %r15     # 0x6f798
movq 0x139e0(%r15), %rsi
movq %rbx, %rdi
callq 0x21f58
movq 0x110(%r15), %rsi
movq %rbx, %rdi
callq 0x21f58
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x3447f
leaq 0x249b5(%rip), %rcx     # 0x58e0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x34481
movq -0x11(%r14), %rdx
jmp 0x34481
movzwl -0x5(%r14), %edx
jmp 0x34481
movl -0x9(%r14), %edx
jmp 0x34481
movzbl -0x3(%r14), %edx
jmp 0x34481
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22a7d
movq 0xa8(%rbx), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x22941
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/pubsub.c
// Function: pubsubUnsubscribeAllCounters
int pubsubUnsubscribeAllCounters(client *c, int notify) {
    dictIterator *di = dictGetSafeIterator(c->sub_counters);
    dictEntry *de;
    sds name;
    int count = 0;

    while((de = dictNext(di)) != NULL) {
        name = dictGetKey(de);

        count += pubsubUnsubscribeCounter(c,name,notify);
    }
    /* We were subscribed to nothing? Still reply to the client. */
    if (notify && count == 0) {
        addReply(c,shared.mbulkhdr[3]);
        addReply(c,shared.unsubscribebulk);
        addReply(c,shared.nullbulk);
        addReplyLongLong(c,dictSize(c->sub_counters));
    }
    dictReleaseIterator(di);
    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %r14
movq 0xa8(%rdi), %rdi
callq 0x1926c
movq %rax, %rbx
movq %rax, %rdi
callq 0x1929d
xorl %ebp, %ebp
testq %rax, %rax
je 0x344fa
movq (%rax), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x34373
addl %eax, %ebp
movq %rbx, %rdi
callq 0x1929d
jmp 0x344db
testl %r15d, %r15d
je 0x3454b
testl %ebp, %ebp
jne 0x3454b
leaq 0x3b28e(%rip), %r15     # 0x6f798
movq 0x139e0(%r15), %rsi
movq %r14, %rdi
callq 0x21f58
movq 0x110(%r15), %rsi
movq %r14, %rdi
callq 0x21f58
movq 0x50(%r15), %rsi
movq %r14, %rdi
callq 0x21f58
movq 0xa8(%r14), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %r14, %rdi
callq 0x22941
movq %rbx, %rdi
callq 0x1935a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/pubsub.c
// Function: subscribeCommand
void subscribeCommand(client *c) {
    int j;

    for (j = 1; j < c->argc; j++)
        pubsubSubscribeCounter(c,c->argv[j]->ptr, 1);
    c->flags |= CLIENT_PUBSUB;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, 0x28(%rdi)
jl 0x34598
movl $0x1, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x34210
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x34573
orb $0x4, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/pubsub.c
// Function: isubscribeCommand
void isubscribeCommand(client *c) {
    int j;
    long long seconds;

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

    for (j = 2; j < c->argc; j++)
        pubsubSubscribeCounter(c,c->argv[j]->ptr, seconds);
    c->flags |= CLIENT_PUBSUB;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rsi
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x266f6
testl %eax, %eax
jne 0x345fb
cmpl $0x3, 0x28(%rbx)
jl 0x345f4
movl $0x2, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq %rbx, %rdi
callq 0x34210
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x345d0
orb $0x4, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/src/pubsub.c
// Function: unsubscribeCommand
void unsubscribeCommand(client *c) {
    if (c->argc == 1) {
        pubsubUnsubscribeAllCounters(c,1);
    } else {
        int j;

        for (j = 1; j < c->argc; j++)
            pubsubUnsubscribeCounter(c,c->argv[j]->ptr,1);
    }
    if (dictSize(c->sub_counters) == 0) c->flags &= ~CLIENT_PUBSUB;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1, 0x28(%rdi)
jne 0x3461f
movq %rbx, %rdi
movl $0x1, %esi
callq 0x344b5
jmp 0x34650
cmpl $0x2, 0x28(%rbx)
jl 0x34650
movl $0x1, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x34373
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x3462b
movq 0xa8(%rbx), %rax
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
jne 0x34668
andb $-0x5, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_arena_init
arena_t *
arena_init(unsigned ind)
{
	arena_t *arena;

	malloc_mutex_lock(&arenas_lock);
	arena = arena_init_locked(ind);
	malloc_mutex_unlock(&arenas_lock);
	return (arena);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4efb4(%rip), %r14     # 0x83758
movq %r14, %rdi
callq 0x12960
movl %ebx, %edi
callq 0x347c9
movq %rax, %rbx
movq %r14, %rdi
callq 0x125c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_narenas_total_get
unsigned
narenas_total_get(void)
{
	unsigned narenas;

	malloc_mutex_lock(&arenas_lock);
	narenas = narenas_total;
	malloc_mutex_unlock(&arenas_lock);

	return (narenas);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x4ef2e(%rip), %rbx     # 0x83758
movq %rbx, %rdi
callq 0x12960
movl 0x4ef48(%rip), %ebp     # 0x83780
movq %rbx, %rdi
callq 0x125c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_arena_migrate
void
arena_migrate(tsd_t *tsd, unsigned oldind, unsigned newind)
{
	arena_t *oldarena, *newarena;

	malloc_mutex_lock(&arenas_lock);
	oldarena = arenas[oldind];
	newarena = arenas[newind];
	oldarena->nthreads--;
	newarena->nthreads++;
	malloc_mutex_unlock(&arenas_lock);
	tsd_arena_set(tsd, newarena);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x4eefa(%rip), %r15     # 0x83758
movq %r15, %rdi
callq 0x12960
movq 0x4ef1b(%rip), %rax     # 0x83788
movl %ebp, %ecx
movq (%rax,%rcx,8), %rcx
movl %ebx, %edx
movq (%rax,%rdx,8), %rbx
decl 0x4(%rcx)
incl 0x4(%rbx)
movq %r15, %rdi
callq 0x125c0
movq %rbx, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_arena_nbound
unsigned
arena_nbound(unsigned ind)
{
	unsigned nthreads;

	malloc_mutex_lock(&arenas_lock);
	nthreads = arenas[ind]->nthreads;
	malloc_mutex_unlock(&arenas_lock);
	return (nthreads);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x4eeb5(%rip), %r14     # 0x83758
movq %r14, %rdi
callq 0x12960
movq 0x4eed6(%rip), %rax     # 0x83788
movl %ebx, %ecx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %ebx
movq %r14, %rdi
callq 0x125c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_arena_choose_hard
arena_t *
arena_choose_hard(tsd_t *tsd)
{
	arena_t *ret;

	if (narenas_auto > 1) {
		unsigned i, choose, first_null;

		choose = 0;
		first_null = narenas_auto;
		malloc_mutex_lock(&arenas_lock);
		assert(a0get() != NULL);
		for (i = 1; i < narenas_auto; i++) {
			if (arenas[i] != NULL) {
				/*
				 * Choose the first arena that has the lowest
				 * number of threads assigned to it.
				 */
				if (arenas[i]->nthreads <
				    arenas[choose]->nthreads)
					choose = i;
			} else if (first_null == narenas_auto) {
				/*
				 * Record the index of the first uninitialized
				 * arena, in case all extant arenas are in use.
				 *
				 * NB: It is possible for there to be
				 * discontinuities in terms of initialized
				 * versus uninitialized arenas, due to the
				 * "thread.arena" mallctl.
				 */
				first_null = i;
			}
		}

		if (arenas[choose]->nthreads == 0
		    || first_null == narenas_auto) {
			/*
			 * Use an unloaded arena, or the least loaded arena if
			 * all arenas are already initialized.
			 */
			ret = arenas[choose];
		} else {
			/* Initialize a new arena. */
			choose = first_null;
			ret = arena_init_locked(choose);
			if (ret == NULL) {
				malloc_mutex_unlock(&arenas_lock);
				return (NULL);
			}
		}
		arena_bind_locked(tsd, choose);
		malloc_mutex_unlock(&arenas_lock);
	} else {
		ret = a0get();
		arena_bind(tsd, 0);
	}

	return (ret);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x4ed24(%rip), %ebp     # 0x83790
cmpl $0x2, %ebp
jb 0x34b03
leaq 0x4ecdc(%rip), %rdi     # 0x83758
callq 0x12960
movl 0x4ed09(%rip), %ecx     # 0x83790
xorl %eax, %eax
cmpq $0x2, %rcx
jb 0x34acb
movq 0x4ecf2(%rip), %rdx     # 0x83788
xorl %eax, %eax
movl $0x1, %esi
movq (%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x34abe
movl 0x4(%rdi), %r8d
movl %eax, %edi
movq (%rdx,%rdi,8), %r9
movl %esi, %edi
cmpl 0x4(%r9), %r8d
jb 0x34aba
movl %eax, %edi
movl %edi, %eax
jmp 0x34ac3
cmpl %ecx, %ebp
cmovel %esi, %ebp
incq %rsi
cmpq %rsi, %rcx
jne 0x34a9d
movq 0x4ecb6(%rip), %rdx     # 0x83788
movl %eax, %esi
movq (%rdx,%rsi,8), %r14
cmpl $0x0, 0x4(%r14)
je 0x34af4
cmpl %ecx, %ebp
je 0x34af4
movl %ebp, %edi
callq 0x347c9
movq %rax, %r14
movl %ebp, %eax
testq %r14, %r14
je 0x34b40
movq 0x4ec8d(%rip), %rcx     # 0x83788
movl %eax, %eax
movq (%rcx,%rax,8), %rax
jmp 0x34b20
movq 0x4ec46(%rip), %r14     # 0x83750
leaq 0x4ec47(%rip), %rdi     # 0x83758
callq 0x12960
movq 0x4ec6b(%rip), %rax     # 0x83788
movq (%rax), %rax
incl 0x4(%rax)
cmpl $0x1, (%rbx)
jne 0x34b2c
movq %rax, 0x28(%rbx)
leaq 0x4ec25(%rip), %rdi     # 0x83758
callq 0x125c0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x34b2c
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_free
JEMALLOC_NOTHROW
je_free(void *ptr)
{

	UTRACE(ptr, 0, 0);
	if (likely(ptr != NULL)) {
		tsd_t *tsd = tsd_fetch();
		ifree(tsd, ptr, tcache_get(tsd, false));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x36484
movq %rdi, %rbx
movq 0x37b92(%rip), %r15     # 0x6dfe8
movq %fs:0x0, %r14
addq %r15, %r14
movl %fs:(%r15), %eax
testl %eax, %eax
je 0x3648a
cmpl $0x2, %eax
je 0x36494
movq %fs:0x8(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x36125
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %fs:(%r15)
jmp 0x3649c
movl $0x3, %fs:(%r15)
leaq 0x4e961(%rip), %rax     # 0x84e04
movl (%rax), %edi
movq %r14, %rsi
callq 0x12990
testl %eax, %eax
je 0x3646f
leaq 0x236fc(%rip), %rdi     # 0x59bb4
callq 0x4f37c
cmpb $0x1, 0x4d26c(%rip)     # 0x83730
jne 0x3646f
callq 0x120c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_dallocx
JEMALLOC_NOTHROW
je_dallocx(void *ptr, int flags)
{
	tsd_t *tsd;
	tcache_t *tcache;

	assert(ptr != NULL);
	assert(malloc_initialized() || IS_INITIALIZER);

	tsd = tsd_fetch();
	if (unlikely((flags & MALLOCX_TCACHE_MASK) != 0)) {
		if ((flags & MALLOCX_TCACHE_MASK) == MALLOCX_TCACHE_NONE)
			tcache = NULL;
		else
			tcache = tcaches_get(tsd, MALLOCX_TCACHE_GET(flags));
	} else
		tcache = tcache_get(tsd, false);

	UTRACE(ptr, 0, 0);
	ifree(tsd_fetch(), ptr, tcache);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq 0x35ee0(%rip), %r12     # 0x6dfe8
movq %fs:0x0, %r14
addq %r12, %r14
movl %fs:(%r12), %eax
testl %eax, %eax
je 0x3816f
cmpl $0x2, %eax
je 0x381ae
andl $0xfff00, %r15d         # imm = 0xFFF00
jne 0x38161
leaq 0x8(%r14), %r15
movq (%r15), %r15
movl %fs:(%r12), %eax
testl %eax, %eax
je 0x3817a
cmpl $0x2, %eax
je 0x381eb
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x36125
cmpl $0x100, %r15d           # imm = 0x100
jne 0x38185
xorl %r15d, %r15d
jmp 0x38136
movl $0x1, %fs:(%r12)
jmp 0x381b7
movl $0x1, %fs:(%r12)
jmp 0x381f4
shrl $0x8, %r15d
addl $-0x2, %r15d
leaq 0x4cc24(%rip), %rax     # 0x84db8
movq (%rax), %rax
leaq (%rax,%r15,8), %r15
cmpq $0x0, (%r15)
jne 0x38133
movq %r14, %rdi
movq %r15, %rsi
callq 0x13878
jmp 0x38133
movl $0x3, %fs:(%r12)
leaq 0x4cc46(%rip), %rax     # 0x84e04
movl (%rax), %edi
movq %r14, %rsi
callq 0x12990
testl %eax, %eax
je 0x38126
leaq 0x219dd(%rip), %rdi     # 0x59bb4
callq 0x4f37c
cmpb $0x1, 0x4b54d(%rip)     # 0x83730
jne 0x38126
jmp 0x38226
movl $0x3, %fs:(%r12)
leaq 0x4cc09(%rip), %rax     # 0x84e04
movl (%rax), %edi
movq %r14, %rsi
callq 0x12990
testl %eax, %eax
je 0x38148
leaq 0x219a0(%rip), %rdi     # 0x59bb4
callq 0x4f37c
cmpb $0x1, 0x4b510(%rip)     # 0x83730
jne 0x38148
callq 0x120c0
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_malloc_usable_size
JEMALLOC_NOTHROW
je_malloc_usable_size(JEMALLOC_USABLE_SIZE_CONST void *ptr)
{
	size_t ret;

	assert(malloc_initialized() || IS_INITIALIZER);
	malloc_thread_init();

	if (config_ivsalloc)
		ret = ivsalloc(ptr, config_prof);
	else
		ret = (ptr == NULL) ? 0 : isalloc(ptr, config_prof);

	return (ret);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x4ac4b(%rip)     # 0x83738
jne 0x38b42
testq %rbx, %rbx
je 0x38b3e
leaq 0x4bba5(%rip), %rax     # 0x846a0
movq (%rax), %rax
notq %rax
andq %rbx, %rax
cmpq %rbx, %rax
je 0x38b49
subq %rax, %rbx
shrq $0xc, %rbx
leaq 0x4ba31(%rip), %rcx     # 0x84548
subq (%rcx), %rbx
movq 0x68(%rax,%rbx,8), %rax
movl %eax, %ecx
shrl $0x5, %ecx
movl $0xff, %edx
andl %edx, %ecx
cmpl %edx, %ecx
je 0x38b52
movl %ecx, %eax
leaq 0x20548(%rip), %rcx     # 0x59080
movq (%rcx,%rax,8), %rax
jmp 0x38b40
xorl %eax, %eax
popq %rbx
retq
callq 0x13cb4
jmp 0x38aef
movq %rbx, %rdi
popq %rbx
jmp 0x48cd7
shrq %rax
andq $-0x1000, %rax          # imm = 0xF000
addq $-0x1000, %rax          # imm = 0xF000
jmp 0x38b40
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: je_jemalloc_postfork_child
void
jemalloc_postfork_child(void)
{
	unsigned i;

	assert(malloc_initialized());

	/* Release all mutexes, now that fork() has completed. */
	base_postfork_child();
	chunk_postfork_child();
	for (i = 0; i < narenas_total; i++) {
		if (arenas[i] != NULL)
			arena_postfork_child(arenas[i]);
	}
	malloc_mutex_postfork_child(&arenas_lock);
	prof_postfork_child();
	ctl_postfork_child();
}

// Assembly:
pushq %rbx
callq 0x400fc
callq 0x411c7
cmpl $0x0, 0x4ab45(%rip)     # 0x83780
je 0x38c62
xorl %ebx, %ebx
movq 0x4ab42(%rip), %rax     # 0x83788
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
je 0x38c54
callq 0x3d91c
incq %rbx
movl 0x4ab23(%rip), %eax     # 0x83780
cmpq %rax, %rbx
jb 0x38c3f
leaq 0x4aaef(%rip), %rdi     # 0x83758
callq 0x48e8c
callq 0x4aa8a
popq %rbx
jmp 0x41bc1
// File: /workspace/github_c_makefile_star2_O1/erikdubbelboer[P]discnt/deps/jemalloc/src/jemalloc.c
// Function: malloc_init_hard_a0
static bool
malloc_init_hard_a0(void)
{
	bool ret;

	malloc_mutex_lock(&init_lock);
	ret = malloc_init_hard_a0_locked();
	malloc_mutex_unlock(&init_lock);
	return (ret);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0x3636d(%rip), %rbx     # 0x6eff0
movq %rbx, %rdi
callq 0x12960
callq 0x38ca3
movl %eax, %ebp
movq %rbx, %rdi
callq 0x125c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq