LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/counter.c
// Function: getCommand
void getCommand(client *c) {
    counter *cntr;

    cntr = counterLookup(c->argv[1]->ptr);
    if (cntr == NULL) {
        if (c->argc == 2) {
            addReplyString(c,OBJ_SHARED_0STR,sizeof(OBJ_SHARED_0STR)-1);
        } else if (!strcasecmp(c->argv[2]->ptr,"state")) {
            addReplyMultiBulkLen(c,2);
            addReplyString(c,OBJ_SHARED_0STR,sizeof(OBJ_SHARED_0STR)-1);
            if (server.cluster->failing_nodes_count > 0) {
                addReplyString(c, OBJ_SHARED_INCONSISTENT, sizeof(OBJ_SHARED_INCONSISTENT)-1);
            } else {
                addReplyString(c, OBJ_SHARED_CONSISTENT, sizeof(OBJ_SHARED_CONSISTENT)-1);
            }
        }
        return;
    }

    countersUpdateValue(cntr);

    if (c->argc == 2) {
        addReplyCounter(c,cntr);
    } else if (!strcasecmp(c->argv[2]->ptr,"state")) {
        addReplyMultiBulkLen(c,2);
        addReplyCounter(c,cntr);
        if (server.cluster->failing_nodes_count > 0) {
            addReplyString(c, OBJ_SHARED_INCONSISTENT, sizeof(OBJ_SHARED_INCONSISTENT)-1);
        } else {
            addReplyString(c, OBJ_SHARED_CONSISTENT, sizeof(OBJ_SHARED_CONSISTENT)-1);
        }
    } else {
        addReplyErrorFormat(c, "Unknown GET option '%s'",
            (char*)c->argv[2]->ptr);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x3dbb6(%rip), %r12     # 0x6f088
movq 0x618(%r12), %rdi
callq 0x18d3e
testq %rax, %rax
je 0x3150c
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x3150c
movq %r14, %rdi
callq 0x30ec8
cmpl $0x2, 0x28(%rbx)
jne 0x3154b
fldt 0x20(%r14)
fstpt (%rsp)
movq %rbx, %rdi
callq 0x224d7
jmp 0x3153f
cmpl $0x2, 0x28(%rbx)
jne 0x31523
leaq 0x27483(%rip), %rsi     # 0x5899c
movl $0x7, %edx
jmp 0x315f0
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x2746e(%rip), %rsi     # 0x589a4
callq 0x12090
testl %eax, %eax
je 0x31589
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r15
leaq 0x27446(%rip), %rsi     # 0x589a4
movq %r15, %rdi
callq 0x12090
testl %eax, %eax
je 0x315ac
leaq 0x2745f(%rip), %rsi     # 0x589d0
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22033
movl $0x2, %esi
movq %rbx, %rdi
callq 0x22676
leaq 0x273ff(%rip), %rsi     # 0x5899c
movl $0x7, %edx
movq %rbx, %rdi
callq 0x21f4a
jmp 0x315c8
movl $0x2, %esi
movq %rbx, %rdi
callq 0x22676
fldt 0x20(%r14)
fstpt (%rsp)
movq %rbx, %rdi
callq 0x224d7
movq 0x668(%r12), %rax
cmpl $0x0, 0x3c(%rax)
jle 0x315e4
leaq 0x273cd(%rip), %rsi     # 0x589aa
movl $0x13, %edx
jmp 0x315f0
leaq 0x273d3(%rip), %rsi     # 0x589be
movl $0x11, %edx
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21f4a
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movslq 0x28(%rdi), %rsi
decq %rsi
callq 0x22676
cmpl $0x2, 0x28(%rbx)
jl 0x3168a
movl $0x1, %r15d
leaq 0x3da58(%rip), %r12     # 0x6f088
leaq 0x27365(%rip), %r14     # 0x5899c
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rsi
movq 0x618(%r12), %rdi
callq 0x18d3e
testq %rax, %rax
je 0x3166e
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x3166e
fldt 0x20(%rax)
fstpt (%rsp)
movq %rbx, %rdi
callq 0x224d7
jmp 0x3167e
movl $0x7, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21f4a
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x31637
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x3d87c(%rip), %r15     # 0x6f088
movq 0x618(%r15), %rdi
callq 0x18d3e
testq %rax, %rax
je 0x31834
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x31834
cmpl $0x2, 0x28(%rbx)
jne 0x3185d
movsd 0x50(%r14), %xmm0
jmp 0x31843
cmpl $0x2, 0x28(%rbx)
jne 0x31855
movsd 0x620(%r15), %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x223db
movb $0x1, %bpl
xorl %r14d, %r14d
jmp 0x3185f
xorl %ebp, %ebp
movq 0x30(%rbx), %rax
movq 0x10(%rax), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x2605d
testl %eax, %eax
jne 0x318ab
testb %bpl, %bpl
je 0x31891
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x30d95
movq %rax, %r14
movsd (%rsp), %xmm0
movsd %xmm0, 0x50(%r14)
incq 0x6a0(%r15)
movq %rbx, %rdi
callq 0x223db
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
movzbl -0x1(%r14), %eax
movq %rax, (%rsp)
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x31a72
leaq 0x26fad(%rip), %rcx     # 0x5889c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rax
shrl $0x3, %eax
jmp 0x31919
movq -0x11(%r14), %rax
jmp 0x31919
movzwl -0x5(%r14), %eax
jmp 0x31919
movl -0x9(%r14), %eax
jmp 0x31919
movzbl -0x3(%r14), %eax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x222ef
movq %rax, 0x8(%rsp)
leaq 0x3d757(%rip), %rax     # 0x6f088
movq 0x618(%rax), %rdi
callq 0x18ec7
movq %rax, %r13
cmpb $0x2a, (%r14)
jne 0x31951
cmpb $0x0, 0x1(%r14)
sete %r15b
jmp 0x31954
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x18ef7
testq %rax, %rax
je 0x31a4a
movq %r14, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x26f51(%rip), %r14     # 0x588c4
movq (%rax), %r12
testb %r15b, %r15b
jne 0x319d8
movzbl -0x1(%r12), %ecx
movl %ecx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x319be
leaq 0x26f1e(%rip), %rdx     # 0x588b0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
shrl $0x3, %ecx
jmp 0x319c0
movq -0x11(%r12), %rcx
jmp 0x319c0
movzwl -0x5(%r12), %ecx
jmp 0x319c0
movl -0x9(%r12), %ecx
jmp 0x319c0
movzbl -0x3(%r12), %ecx
jmp 0x319c0
xorl %ecx, %ecx
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x24a34
testl %eax, %eax
je 0x31a37
movzbl -0x1(%r12), %esi
movl %esi, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x31a14
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
shrl $0x3, %esi
jmp 0x31a16
movq -0x11(%r12), %rsi
jmp 0x31a16
movzwl -0x5(%r12), %esi
jmp 0x31a16
movl -0x9(%r12), %esi
jmp 0x31a16
movzbl -0x3(%r12), %esi
jmp 0x31a16
xorl %esi, %esi
movq %r12, %rdi
callq 0x25710
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22748
incq %rbp
movq %r12, %rdi
callq 0x25945
movq %r13, %rdi
callq 0x18ef7
testq %rax, %rax
jne 0x31973
jmp 0x31a4c
xorl %ebp, %ebp
movq %r13, %rdi
callq 0x18fbf
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22315
movq $0x0, (%rsp)
jmp 0x3191d
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rsi
leaq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x261b6
testl %eax, %eax
jne 0x31ae4
movslq 0x28(%rbx), %rsi
addq $-0x2, %rsi
movq %rbx, %rdi
callq 0x22676
cmpl $0x3, 0x28(%rbx)
jl 0x31ae4
movl $0x2, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
fldt 0x10(%rsp)
fstpt (%rsp)
movq %rbx, %rdi
callq 0x3129b
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x31abd
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3d587(%rip), %rax     # 0x6f088
movq 0x618(%rax), %rdi
callq 0x18e9d
movq %rax, %r14
movq %rax, %rdi
callq 0x18ef7
testq %rax, %rax
je 0x31b80
leaq 0x8(%rsp), %r15
movq 0x8(%rax), %r12
cmpq $0x0, 0x10(%r12)
je 0x31b39
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2e4f3
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x16717
movq %r15, %rdi
callq 0x16734
testq %rax, %rax
je 0x31b73
movq 0x10(%rax), %r12
leaq 0x8(%r12), %rdi
movl $0x28, %edx
movq %rbx, %rsi
callq 0x12610
testl %eax, %eax
jne 0x31b46
movq %rbx, (%r12)
jmp 0x31b46
movq %r14, %rdi
callq 0x18ef7
testq %rax, %rax
jne 0x31b22
movq %r14, %rdi
callq 0x18fbf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31c2d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
je 0x31c22
movq %rdi, %rbx
movq 0x48(%rdi), %r14
callq 0x19e27
addq $-0x1388, %rax          # imm = 0xEC78
cmpq %rax, %r14
jg 0x31c22
leaq 0x3d4b7(%rip), %r15     # 0x6f088
movq 0x668(%r15), %rax
cmpl $0x0, 0x38(%rax)
jle 0x31c22
xorl %r12d, %r12d
movq 0x30(%rax), %rax
movq (%rax,%r12,8), %r14
cmpq $0x0, 0x88(%r14)
je 0x31c0f
movq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x18d3e
testq %rax, %rax
je 0x31c0f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e4f3
incq %r12
movq 0x668(%r15), %rax
movslq 0x38(%rax), %rcx
cmpq %rcx, %r12
jl 0x31be1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19e27
movq %rax, %rbx
leaq 0x3d21e(%rip), %r12     # 0x6f088
movq 0x618(%r12), %rdi
callq 0x18ec7
movq %rax, %r14
movq %rax, %rdi
callq 0x18ef7
testq %rax, %rax
je 0x31f58
addq $-0x7d0, %rbx           # imm = 0xF830
movq %rsp, %r15
movq 0x8(%rax), %r13
movq 0x40(%r13), %rax
testq %rax, %rax
je 0x31eb0
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
jne 0x31f47
movq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x16717
movq %r15, %rdi
callq 0x16734
testq %rax, %rax
je 0x31f24
movq 0x10(%rax), %rcx
movq 0x40(%rcx), %rdx
testq %rdx, %rdx
je 0x31ebc
cmpq %rbx, %rdx
jg 0x31ebc
fldt 0x30(%rcx)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x31ebc
jp 0x31ebc
fldt 0x50(%rcx)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x31ebc
jp 0x31ebc
fldt 0x60(%rcx)
fldz
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x31ebc
jp 0x31ebc
cmpq 0x10(%r13), %rcx
jne 0x31f16
movq $0x0, 0x10(%r13)
movq 0x8(%r13), %rdi
movq %rax, %rsi
callq 0x16691
jmp 0x31ebc
movq 0x8(%r13), %rax
cmpq $0x0, 0x28(%rax)
jne 0x31f47
cmpq $0x0, 0x60(%r13)
jne 0x31f47
movq 0x618(%r12), %rdi
movq (%r13), %rsi
callq 0x18a7c
movq %r14, %rdi
callq 0x18ef7
testq %rax, %rax
jne 0x31e95
movq %r14, %rdi
callq 0x18fbf
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movl $0x8, %r13d
movq 0x38(%r14), %rax
cmpq %r13, %rax
movq %r13, %r12
cmovbq %rax, %r12
testq %rax, %rax
cmoveq %r13, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r14)
testq %rax, %rax
je 0x32123
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x3210b
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
addq %r12, %r15
addq %r12, 0x30(%r14)
subq %r12, %r13
jne 0x320d1
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x32128
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31fab
cmpl $-0x1, %eax
je 0x3220f
movslq %eax, %r14
testq %rbx, %rbx
je 0x32216
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x31fab
addq %rbx, %r14
cmpl $-0x1, %eax
movq $-0x1, %rax
cmoveq %rax, %r14
jmp 0x32216
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3214d
cmpl $-0x1, %eax
je 0x32263
movl %eax, %ebp
movl %eax, %r14d
testq %rbx, %rbx
movq %r14, (%rsp)
je 0x32284
movq %rbx, %rdi
callq 0x1dc92
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1e2fb
jmp 0x3228e
testq %rbx, %rbx
je 0x32270
movq %rbx, %rdi
callq 0x1dc25
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
movq %r14, %rsi
callq 0x1da70
movq %rax, %rbx
testl %ebp, %ebp
je 0x322e2
movq (%rsp), %r14
movq %rbx, %r12
movq 0x38(%r15), %rax
cmpq %r14, %rax
movq %r14, %r13
cmovbq %rax, %r13
testq %rax, %rax
cmoveq %r14, %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *(%r15)
testq %rax, %rax
je 0x32268
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x322d6
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *%rax
addq %r13, %r12
addq %r13, 0x30(%r15)
subq %r13, %r14
jne 0x3229c
movzbl -0x1(%rbx), %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x32272
leaq 0x26753(%rip), %rcx     # 0x58a48
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shlb $0x3, %bpl
movb %bpl, -0x1(%rbx)
jmp 0x32272
movq (%rsp), %rax
movq %rax, -0x11(%rbx)
jmp 0x32272
movw %bp, -0x5(%rbx)
jmp 0x32272
movl %ebp, -0x9(%rbx)
jmp 0x32272
movb %bpl, -0x3(%rbx)
jmp 0x32272
// File: /workspace/github_c_makefile_star2_O3/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 0x323e1
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 0x32399
fldz
fucompi %st(1), %st
fstp %st(0)
seta %al
orb $-0x2, %al
movb %al, 0x20(%rsp)
movl $0x1, %edx
jmp 0x323c9
leaq 0x21(%rsp), %r14
fstpt (%rsp)
leaq 0x228d0(%rip), %rdx     # 0x54c78
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 0x31fab
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
fstp %st(0)
movb $-0x3, 0x20(%rsp)
jmp 0x32392
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq %rdi, %r14
leaq 0xf(%rsp), %r15
movl $0x1, %r13d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x38(%r14), %rax
cmpq %r13, %rax
movq %r13, %r12
cmovbq %rax, %r12
testq %rax, %rax
cmoveq %r13, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r14)
testq %rax, %rax
je 0x3253c
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x3244f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
addq %r12, %r15
addq %r12, 0x30(%r14)
subq %r12, %r13
jne 0x32411
movzbl 0xf(%rsp), %r13d
cmpl $0xfd, %r13d
jg 0x32488
testl %r13d, %r13d
je 0x324fb
cmpl $0xfd, %r13d
jne 0x324aa
leaq 0x50ef5(%rip), %rax     # 0x83378
jmp 0x32536
cmpl $0xfe, %r13d
je 0x3252f
cmpl $0xff, %r13d
jne 0x324aa
leaq 0x50ecb(%rip), %rax     # 0x83370
jmp 0x32536
leaq 0x10(%rsp), %r15
movq 0x38(%r14), %rax
cmpq %r13, %rax
movq %r13, %r12
cmovbq %rax, %r12
testq %rax, %rax
cmoveq %r13, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%r14)
testq %rax, %rax
je 0x3253c
movq 0x20(%r14), %rax
testq %rax, %rax
je 0x324e9
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *%rax
addq %r12, %r15
addq %r12, 0x30(%r14)
subq %r12, %r13
jne 0x324af
movzbl 0xf(%rsp), %r13d
movb $0x0, 0x10(%rsp,%r13)
leaq 0x265c0(%rip), %rsi     # 0x58ac8
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x125e0
fldt (%rbx)
fabs
fldz
fldl 0x263b3(%rip)           # 0x588d8
fxch %st(2)
fucompi %st(2), %st
fstp %st(1)
ja 0x32538
jmp 0x3253e
leaq 0x50e32(%rip), %rax     # 0x83368
fldl (%rax)
fstpt (%rbx)
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
// File: /workspace/github_c_makefile_star2_O3/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 0x3c053(%rip), %r15     # 0x6f088
cmpl $0x0, 0x6d4(%r15)
je 0x3304a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x335cd
movq 0x340(%r15), %rdi
testq %rdi, %rdi
je 0x3308d
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 0x3308d
callq 0x1a603
movq 0x30(%rbx), %rdi
callq 0x32fda
popq %rbx
popq %r14
popq %r15
jmp 0x249ec
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x332c2
movl %esi, %ebx
testl %esi, %esi
setne %al
testl %edi, %edi
sete %cl
orb %al, %cl
jne 0x33300
leaq 0x25a30(%rip), %rsi     # 0x58cdb
movl $0x3, %edi
xorl %eax, %eax
callq 0x19c06
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x333a0
leaq 0x259e8(%rip), %rsi     # 0x58cb1
xorl %r14d, %r14d
movl $0x2, %edi
xorl %eax, %eax
callq 0x19c06
leaq 0x3bda9(%rip), %rbx     # 0x6f088
movq 0x6a8(%rbx), %rax
subq %rax, 0x6a0(%rbx)
xorl %edi, %edi
callq 0x12540
movq %rax, 0x6d8(%rbx)
jmp 0x333a0
leaq 0x259ec(%rip), %rsi     # 0x58cf3
xorl %r14d, %r14d
movl $0x3, %edi
movl %ebx, %edx
xorl %eax, %eax
callq 0x19c06
leaq 0x3bd69(%rip), %r12     # 0x6f088
cmpq $0x0, 0x670(%r12)
je 0x33332
callq 0x19e27
movq %rax, %r14
movl 0x6b0(%r12), %ecx
leaq 0x25796(%rip), %rdx     # 0x58ad7
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 0x33395
callq 0x19e27
subq %r14, %rax
movq 0x670(%r12), %rcx
testq %rcx, %rcx
sete %dl
cmpq %rcx, %rax
setl %cl
orb %dl, %cl
jne 0x33395
leaq 0x24f30(%rip), %rdi     # 0x582bd
movq %rax, %rsi
callq 0x2fd96
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl $0xa, %ebx
je 0x333ae
leaq 0x3bce1(%rip), %rax     # 0x6f088
movl %r14d, 0x6fc(%rax)
leaq 0x3bcd3(%rip), %rbx     # 0x6f088
movl $0xffffffff, 0x6b0(%rbx) # imm = 0xFFFFFFFF
movl $0x0, 0x6f8(%rbx)
xorl %edi, %edi
callq 0x12540
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_O3/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 0x3bc4d(%rip), %rax     # 0x6f088
cmpl $-0x1, 0x6b0(%rax)
je 0x33454
leaq 0x258f2(%rip), %rsi     # 0x58d3d
movq %rbx, %rdi
popq %rbx
jmp 0x2200c
movq 0x6c8(%rax), %rdi
callq 0x32996
testl %eax, %eax
je 0x33471
leaq 0x3c32d(%rip), %rax     # 0x6f798
movq 0x10(%rax), %rsi
jmp 0x3347c
leaq 0x3c320(%rip), %rax     # 0x6f798
movq 0x8(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x21c5a
// File: /workspace/github_c_makefile_star2_O3/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 0x3bbf8(%rip), %rax     # 0x6f088
cmpl $-0x1, 0x6b0(%rax)
je 0x334a9
leaq 0x2589d(%rip), %rsi     # 0x58d3d
movq %rbx, %rdi
popq %rbx
jmp 0x2200c
movq 0x6c8(%rax), %rdi
callq 0x32b42
testl %eax, %eax
je 0x334cd
leaq 0x3c2d8(%rip), %rax     # 0x6f798
movq 0x10(%rax), %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x21c5a
leaq 0x2588d(%rip), %rsi     # 0x58d61
movq %rbx, %rdi
popq %rbx
jmp 0x221d1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x30d6f
movq %rax, %r12
testq %rax, %rax
jne 0x33b74
movq %r14, %rdi
callq 0x30d95
movq %rax, %r12
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
jne 0x33b98
leaq 0x3b249(%rip), %rdi     # 0x6edd0
xorl %esi, %esi
callq 0x184d5
movq %rax, %rdi
movq %rax, 0xa8(%rbx)
movq (%r12), %rsi
movq %r12, %rdx
callq 0x18802
xorl %ebp, %ebp
testl %eax, %eax
jne 0x33bf5
cmpq $0x0, 0x60(%r12)
jne 0x33bbc
callq 0x164dc
movq %rax, 0x60(%r12)
movl $0x30, %edi
callq 0x1fbbd
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
movq $0x0, 0x10(%rax)
fldz
fstpt 0x20(%rax)
movq 0x60(%r12), %rdi
movq %rax, %rsi
callq 0x165ab
movl $0x1, %ebp
testq %rax, %rax
je 0x33c87
leaq 0x3bb9c(%rip), %r15     # 0x6f798
movq 0x139e0(%r15), %rsi
movq %rbx, %rdi
callq 0x21c5a
movq 0x108(%r15), %rsi
movq %rbx, %rdi
callq 0x21c5a
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x33c58
leaq 0x251a8(%rip), %rcx     # 0x58dd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x33c5a
movq -0x11(%r14), %rdx
jmp 0x33c5a
movzwl -0x5(%r14), %edx
jmp 0x33c5a
movl -0x9(%r14), %edx
jmp 0x33c5a
movzbl -0x3(%r14), %edx
jmp 0x33c5a
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2277b
movq 0xa8(%rbx), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x22641
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25172(%rip), %rdi     # 0x58e00
leaq 0x25198(%rip), %rsi     # 0x58e2d
movl $0x41, %edx
callq 0x2a46a
movl $0x1, %edi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O3/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 0x33d49
movq %r14, %rsi
callq 0x18c05
testq %rax, %rax
je 0x33d49
movq 0x8(%rax), %rbp
movq 0xa8(%rbx), %rdi
movq %rax, %rsi
callq 0x18c0f
movq 0x60(%rbp), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x16717
movq %r12, %rdi
callq 0x16734
testq %rax, %rax
je 0x33d2b
movq 0x10(%rax), %r13
cmpq %rbx, (%r13)
jne 0x33d00
movq 0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x16691
movq %r13, %rdi
callq 0x1fd17
movq 0x60(%rbp), %rdi
movl $0x1, %r12d
cmpq $0x0, 0x28(%rdi)
jne 0x33d49
callq 0x164fc
movq $0x0, 0x60(%rbp)
testl %r15d, %r15d
je 0x33dd9
leaq 0x3ba3f(%rip), %r15     # 0x6f798
movq 0x139e0(%r15), %rsi
movq %rbx, %rdi
callq 0x21c5a
movq 0x110(%r15), %rsi
movq %rbx, %rdi
callq 0x21c5a
movzbl -0x1(%r14), %edx
movl %edx, %eax
andl $0x7, %eax
cmpl $0x4, %eax
ja 0x33db5
leaq 0x2505f(%rip), %rcx     # 0x58dec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrl $0x3, %edx
jmp 0x33db7
movq -0x11(%r14), %rdx
jmp 0x33db7
movzwl -0x5(%r14), %edx
jmp 0x33db7
movl -0x9(%r14), %edx
jmp 0x33db7
movzbl -0x3(%r14), %edx
jmp 0x33db7
xorl %edx, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2277b
movq 0xa8(%rbx), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x22641
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_O3/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 0x18ec7
movq %rax, %rbx
movq %rax, %rdi
callq 0x18ef7
xorl %ebp, %ebp
testq %rax, %rax
je 0x33e30
movq (%rax), %rsi
movq %r14, %rdi
movl %r15d, %edx
callq 0x33ca9
addl %eax, %ebp
movq %rbx, %rdi
callq 0x18ef7
jmp 0x33e11
testl %r15d, %r15d
je 0x33e81
testl %ebp, %ebp
jne 0x33e81
leaq 0x3b958(%rip), %r15     # 0x6f798
movq 0x139e0(%r15), %rsi
movq %r14, %rdi
callq 0x21c5a
movq 0x110(%r15), %rsi
movq %r14, %rdi
callq 0x21c5a
movq 0x50(%r15), %rsi
movq %r14, %rdi
callq 0x21c5a
movq 0xa8(%r14), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %r14, %rdi
callq 0x22641
movq %rbx, %rdi
callq 0x18fbf
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x33ece
movl $0x1, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x33b48
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x33ea9
orb $0x4, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x262f3
testl %eax, %eax
jne 0x33f31
cmpl $0x3, 0x28(%rbx)
jl 0x33f2a
movl $0x2, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq %rbx, %rdi
callq 0x33b48
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x33f06
orb $0x4, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
jne 0x33f57
movq %rbx, %rdi
movl $0x1, %esi
callq 0x33deb
jmp 0x33f84
jle 0x33f84
movl $0x1, %r14d
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x33ca9
incq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jl 0x33f5f
movq 0xa8(%rbx), %rax
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
jne 0x33f9c
andb $-0x5, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h
// Function: je_size2index_compute
JEMALLOC_INLINE szind_t
size2index_compute(size_t size)
{

#if (NTBINS != 0)
	if (size <= (ZU(1) << LG_TINY_MAXCLASS)) {
		size_t lg_tmin = LG_TINY_MAXCLASS - NTBINS + 1;
		size_t lg_ceil = lg_floor(pow2_ceil(size));
		return (lg_ceil < lg_tmin ? 0 : lg_ceil - lg_tmin);
	}
#endif
	{
		size_t x = unlikely(ZI(size) < 0) ? ((size<<1) ?
		    (ZU(1)<<(LG_SIZEOF_PTR+3)) : ((ZU(1)<<(LG_SIZEOF_PTR+3))-1))
		    : lg_floor((size<<1)-1);
		size_t shift = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM) ? 0 :
		    x - (LG_SIZE_CLASS_GROUP + LG_QUANTUM);
		size_t grp = shift << LG_SIZE_CLASS_GROUP;

		size_t lg_delta = (x < LG_SIZE_CLASS_GROUP + LG_QUANTUM + 1)
		    ? LG_QUANTUM : x - LG_SIZE_CLASS_GROUP - 1;

		size_t delta_inverse_mask = ZI(-1) << lg_delta;
		size_t mod = ((((size-1) & delta_inverse_mask) >> lg_delta)) &
		    ((ZU(1) << LG_SIZE_CLASS_GROUP) - 1);

		size_t index = NTBINS + grp + mod;
		return (index);
	}
}

// Assembly:
cmpq $0x8, %rdi
ja 0x49210
decq %rdi
movq %rdi, %rax
shrq %rax
orq %rdi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x20, %rcx
orq %rax, %rcx
incq %rcx
bsrq %rcx, %rcx
xorl %eax, %eax
subq $0x3, %rcx
cmovaeq %rcx, %rax
retq
testq %rdi, %rdi
js 0x49257
leaq -0x1(,%rdi,2), %rax
bsrq %rax, %rcx
xorl %eax, %eax
movq %rcx, %rdx
subq $0x6, %rdx
cmovaeq %rdx, %rax
leal -0x3(%rcx), %edx
cmpq $0x7, %rcx
movzbl %dl, %edx
movl $0x4, %ecx
cmovael %edx, %ecx
decq %rdi
shrq %cl, %rdi
shlq %cl, %rdi
shrq %cl, %rdi
andl $0x3, %edi
leaq (%rdi,%rax,4), %rax
incq %rax
retq
movq %rdi, %rax
btrq $0x3f, %rax
cmpq $0x1, %rax
movl $0x40, %ecx
sbbq $0x0, %rcx
jmp 0x49221
nop
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/signal1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	struct sigaction act;

	memset(&act, 0, sizeof(act));
	act.sa_handler = handler;
	sigaction(SIGUSR1, &act, NULL);

	while (1) {
		raise(SIGUSR1);

		(*iterations)++;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1140
leaq -0x29(%rip), %rax       # 0x1cf0
movq %rax, -0x8(%r14)
movq %rsp, %rsi
movl $0xa, %edi
xorl %edx, %edx
callq 0x10c0
movl $0xa, %edi
callq 0x1050
incq (%rbx)
jmp 0x1d2c
// File: /workspace/github_c_makefile_star2_O3/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_chacha20_H
void crypto_chacha20_H(u8 out[32], const u8 key[32], const u8 in[16])
{
    crypto_chacha_ctx ctx;
    chacha20_init_key(&ctx, key);
    FOR (i, 0, 4) {
        ctx.input[i+12] = load32_le(in + i*4);
    }
    u32 buffer[16];
    chacha20_rounds(buffer, ctx.input);
    // prevents reversal of the rounds by revealing only half of the buffer.
    FOR (i, 0, 4) {
        store32_le(out      + i*4, buffer[i     ]); // constant
        store32_le(out + 16 + i*4, buffer[i + 12]); // counter and nonce
    }
    WIPE_CTX(&ctx);
    WIPE_BUFFER(buffer);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movaps 0x7d64(%rip), %xmm0     # 0x95a0
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, 0x10(%rax)
movaps %xmm1, 0x20(%rax)
movups (%rdx), %xmm0
movaps %xmm0, 0x30(%rax)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x18a8
xorl %eax, %eax
movl (%rsp,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
movl 0x30(%rsp,%rax,4), %ecx
movl %ecx, 0x10(%rbx,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0x1867
xorl %eax, %eax
movb $0x0, 0x40(%rsp,%rax)
incq %rax
cmpq $0x88, %rax
jne 0x1880
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x40, %rax
jne 0x1892
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_chacha20_init
static void chacha20_init_key(crypto_chacha_ctx *ctx, const u8 key[32])
{
    // constant
    ctx->input[0] = load32_le((u8*)"expa");
    ctx->input[1] = load32_le((u8*)"nd 3");
    ctx->input[2] = load32_le((u8*)"2-by");
    ctx->input[3] = load32_le((u8*)"te k");
    // key
    FOR (i, 0, 8) {
        ctx->input[i+4] = load32_le(key + i*4);
    }
}

// Assembly:
movaps 0x7ac8(%rip), %xmm0     # 0x95a0
movups %xmm0, (%rdi)
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, 0x10(%rdi,%rax,4)
incq %rax
cmpq $0x8, %rax
jne 0x1add
movq $0x0, 0x30(%rdi)
movq $0x40, 0x80(%rdi)
movl (%rdx), %eax
movl %eax, 0x38(%rdi)
movl 0x4(%rdx), %eax
movl %eax, 0x3c(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_chacha20_x_init
void crypto_chacha20_x_init(crypto_chacha_ctx *ctx,
                            const u8           key[32],
                            const u8           nonce[24])
{
    u8 derived_key[32];
    crypto_chacha20_H(derived_key, key, nonce);
    crypto_chacha20_init(ctx, derived_key, nonce + 16);
    WIPE_BUFFER(derived_key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x182a
movaps 0x7a5d(%rip), %xmm0     # 0x95a0
movups %xmm0, (%r14)
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movups %xmm0, 0x10(%r14)
movups %xmm1, 0x20(%r14)
movq $0x0, 0x30(%r14)
movq $0x40, 0x80(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x38(%r14)
movl 0x14(%rbx), %eax
movl %eax, 0x3c(%r14)
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
incq %rax
cmpq $0x20, %rax
jne 0x1b7d
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_chacha20_encrypt
void crypto_chacha20_encrypt(crypto_chacha_ctx *ctx,
                             u8                *cipher_text,
                             const u8          *plain_text,
                             size_t             text_size)
{
    // Align ourselves with block boundaries
    size_t align = MIN(ALIGN(ctx->pool_idx, 64), text_size);
    chacha20_encrypt(ctx, cipher_text, plain_text, align);
    if (plain_text != 0) {
        plain_text += align;
    }
    cipher_text += align;
    text_size   -= align;

    // Process the message block by block
    FOR (i, 0, text_size >> 6) {  // number of blocks
        chacha20_refill_pool(ctx);
        if (plain_text != 0) {
            FOR (j, 0, 16) {
                u32 plain = load32_le(plain_text);
                store32_le(cipher_text, ctx->pool[j] ^ plain);
                plain_text  += 4;
                cipher_text += 4;
            }
        } else {
            FOR (j, 0, 16) {
                store32_le(cipher_text, ctx->pool[j]);
                cipher_text += 4;
            }
        }
        ctx->pool_idx = 64;
    }
    text_size &= 63;

    // remaining bytes
    chacha20_encrypt(ctx, cipher_text, plain_text, text_size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
subl 0x80(%rdi), %ebp
andl $0x3f, %ebp
cmpq %rcx, %rbp
cmovaeq %rcx, %rbp
movq %rbp, %rcx
callq 0x1c60
movq %r13, %r12
addq %rbp, %r12
testq %r13, %r13
cmoveq %r13, %r12
addq %rbp, %r14
subq %rbp, %rbx
cmpq $0x40, %rbx
jb 0x1c41
movq %rbx, %r13
shrq $0x6, %r13
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x1ce3
xorl %eax, %eax
testq %r12, %r12
je 0x1c15
movl 0x40(%r15,%rax), %ecx
xorl (%r12,%rax), %ecx
movl %ecx, (%r14,%rax)
addq $0x4, %rax
cmpq $0x40, %rax
jne 0x1bf6
addq %rax, %r14
addq %rax, %r12
jmp 0x1c2e
movl 0x40(%r15,%rax), %ecx
movl %ecx, (%r14,%rax)
addq $0x4, %rax
cmpq $0x40, %rax
jne 0x1c15
addq %rax, %r14
xorl %r12d, %r12d
movq $0x40, 0x80(%r15)
incq %rbp
cmpq %r13, %rbp
jne 0x1be7
andl $0x3f, %ebx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1c60
// File: /workspace/github_c_makefile_star2_O3/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: chacha20_encrypt
static void chacha20_encrypt(crypto_chacha_ctx *ctx,
                             u8                *cipher_text,
                             const u8          *plain_text,
                             size_t             text_size)
{
    FOR (i, 0, text_size) {
        if (ctx->pool_idx == 64) {
            chacha20_refill_pool(ctx);
        }
        u8 plain = 0;
        if (plain_text != 0) {
            plain = *plain_text;
            plain_text++;
        }
        *cipher_text = chacha20_pool_byte(ctx) ^ plain;
        cipher_text++;
    }
}

// Assembly:
testq %rcx, %rcx
je 0x1ce2
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
xorl %r13d, %r13d
cmpq $0x40, 0x80(%r12)
jne 0x1c90
movq %r12, %rdi
callq 0x1ce3
testq %r15, %r15
je 0x1c9d
movb (%r15), %al
incq %r15
jmp 0x1ca2
xorl %r15d, %r15d
xorl %eax, %eax
movq 0x80(%r12), %rdx
movq %rdx, %rcx
andq $-0x4, %rcx
movl 0x40(%r12,%rcx), %esi
leal (,%rdx,8), %ecx
shrl %cl, %esi
incq %rdx
movq %rdx, 0x80(%r12)
xorb %al, %sil
movb %sil, (%r14,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x1c7d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq