LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x121(%rbp), %rsi
movl $0x1, %edx
callq 0x3afa0
cmpq $0x0, %rax
jne 0x3b4ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b5d8
movzbl -0x121(%rbp), %eax
movl %eax, -0x128(%rbp)
subl $0xfd, %eax
je 0x3b534
jmp 0x3b4e0
movl -0x128(%rbp), %eax
subl $0xfe, %eax
je 0x3b519
jmp 0x3b4ef
movl -0x128(%rbp), %eax
subl $0xff, %eax
jne 0x3b54f
jmp 0x3b4fe
leaq 0x97ecb(%rip), %rax     # 0xd33d0
fldl (%rax)
movq -0x18(%rbp), %rax
fstpt (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3b5d8
leaq 0x97ea8(%rip), %rax     # 0xd33c8
fldl (%rax)
movq -0x18(%rbp), %rax
fstpt (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3b5d8
leaq 0x97e9d(%rip), %rax     # 0xd33d8
fldl (%rax)
movq -0x18(%rbp), %rax
fstpt (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3b5d8
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movzbl -0x121(%rbp), %eax
movl %eax, %edx
callq 0x3afa0
cmpq $0x0, %rax
jne 0x3b577
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b5d8
movzbl -0x121(%rbp), %eax
movb $0x0, -0x120(%rbp,%rax)
movq -0x18(%rbp), %rdx
leaq 0x6decf(%rip), %rsi     # 0xa9460
xorl %eax, %eax
leaq -0x120(%rbp), %rdi
callq 0x125d0
movq -0x18(%rbp), %rax
fldt (%rax)
fldl 0x6dcf5(%rip)           # 0xa92a0
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
ja 0x3b5c9
jmp 0x3b5b5
movq -0x18(%rbp), %rax
fldt (%rax)
fldl 0x6dce7(%rip)           # 0xa92a8
fucompi %st(1), %st
fstp %st(0)
jbe 0x3b5d1
jmp 0x3b5c9
movq -0x18(%rbp), %rax
fldz
fstpt (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/ddb.c
// Function: ddbLoadDouble
int ddbLoadDouble(rio *ddb, double *val) {
    int r;
    long double d;
    if ((r = ddbLoadLongDouble(ddb,&d)) == -1) return -1;
    *val = d;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3b490
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x3b61e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3b638
fldt -0x30(%rbp)
fstpl -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x82b8d(%rip), %rax     # 0xbf0e8
cmpl $0x0, 0x6d4(%rax)
je 0x3c575
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3cdb0
leaq 0x82b6c(%rip), %rax     # 0xbf0e8
cmpq $0x0, 0x340(%rax)
je 0x3c5e1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
addq -0x18(%rbp), %rax
leaq 0x82b4f(%rip), %rcx     # 0xbf0e8
xorl %edx, %edx
divq 0x340(%rcx)
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
leaq 0x82b33(%rip), %rcx     # 0xbf0e8
xorl %edx, %edx
divq 0x340(%rcx)
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jbe 0x3c5e1
callq 0x19a30
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3c4c0
callq 0x27ba0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/erikdubbelboer[P]discnt/src/ddb.c
// Function: backgroundSaveDoneHandler
void backgroundSaveDoneHandler(int exitcode, int bysignal) {
    switch(server.ddb_child_type) {
    case DDB_CHILD_TYPE_DISK:
        backgroundSaveDoneHandlerDisk(exitcode,bysignal);
        break;
    default:
        serverPanic("Unknown DDB child type.");
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x82633(%rip), %rax     # 0xbf0e8
movl 0x6f8(%rax), %eax
subl $0x1, %eax
jne 0x3cacf
jmp 0x3cac2
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x3c8c0
jmp 0x3caf1
leaq 0x6cc4e(%rip), %rdi     # 0xa9724
leaq 0x6cc61(%rip), %rsi     # 0xa973e
movl $0x26f, %edx            # imm = 0x26F
callq 0x304a0
movl $0x1, %edi
callq 0x12100
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x825d5(%rip), %rax     # 0xbf0e8
cmpl $-0x1, 0x6b0(%rax)
je 0x3cb2e
movq -0x8(%rbp), %rdi
leaq 0x6cc1d(%rip), %rsi     # 0xa9744
callq 0x24320
jmp 0x3cb70
leaq 0x825b3(%rip), %rax     # 0xbf0e8
movq 0x6c8(%rax), %rdi
callq 0x3bcd0
cmpl $0x0, %eax
jne 0x3cb5c
movq -0x8(%rbp), %rdi
leaq 0x82ca7(%rip), %rax     # 0xbf7f8
movq 0x8(%rax), %rsi
callq 0x24050
jmp 0x3cb70
movq -0x8(%rbp), %rdi
leaq 0x82c91(%rip), %rax     # 0xbf7f8
movq 0x10(%rax), %rsi
callq 0x24050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x82555(%rip), %rax     # 0xbf0e8
cmpl $-0x1, 0x6b0(%rax)
je 0x3cbae
movq -0x8(%rbp), %rdi
leaq 0x6cb9d(%rip), %rsi     # 0xa9744
callq 0x24320
jmp 0x3cbee
leaq 0x82533(%rip), %rax     # 0xbf0e8
movq 0x6c8(%rax), %rdi
callq 0x3bf00
cmpl $0x0, %eax
jne 0x3cbd8
movq -0x8(%rbp), %rdi
leaq 0x6cb97(%rip), %rsi     # 0xa9768
callq 0x24510
jmp 0x3cbec
movq -0x8(%rbp), %rdi
leaq 0x82c15(%rip), %rax     # 0xbf7f8
movq 0x10(%rax), %rsi
callq 0x24050
jmp 0x3cbee
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x396f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3d6fc
movq -0x10(%rbp), %rdi
callq 0x39740
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
jne 0x3d728
leaq 0x816bf(%rip), %rdi     # 0xbedd0
xorl %eax, %eax
movl %eax, %esi
callq 0x16120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x166b0
cmpl $0x0, %eax
jne 0x3d7e5
movl $0x1, -0x1c(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x3d76e
callq 0x12b00
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x30, %edi
callq 0x20a00
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
fldz
fstpt 0x20(%rax)
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x12ce0
cmpq $0x0, %rax
je 0x3d7c1
jmp 0x3d7e3
leaq 0x6c004(%rip), %rdi     # 0xa97cc
leaq 0x6c02a(%rip), %rsi     # 0xa97f9
movl $0x41, %edx
callq 0x300b0
movl $0x1, %edi
callq 0x12100
jmp 0x3d7e5
movq -0x8(%rbp), %rdi
leaq 0x82008(%rip), %rax     # 0xbf7f8
movq 0x139e0(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rdi
leaq 0x81ff1(%rip), %rax     # 0xbf7f8
movq 0x108(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d870
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x24ca0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
addq 0x48(%rax), %rsi
callq 0x24ab0
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x3d9fd
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x16dd0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3d9fb
movl $0x1, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x16e00
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x13000
leaq -0x30(%rbp), %rdi
callq 0x13060
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3d9d1
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x3d9cf
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x12ec0
movq -0x50(%rbp), %rdi
callq 0x20ce0
jmp 0x3d9d1
jmp 0x3d987
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rax
cmpq $0x0, 0x28(%rax)
jne 0x3d9f9
movq -0x48(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x12b80
movq -0x48(%rbp), %rax
movq $0x0, 0x60(%rax)
jmp 0x3d9fb
jmp 0x3d9fd
cmpl $0x0, -0x14(%rbp)
je 0x3da81
movq -0x8(%rbp), %rdi
leaq 0x81dea(%rip), %rax     # 0xbf7f8
movq 0x139e0(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rdi
leaq 0x81dd3(%rip), %rax     # 0xbf7f8
movq 0x110(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3d870
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
callq 0x24ca0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
addq 0x48(%rax), %rsi
callq 0x24ab0
movl -0x3c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x17370
movq %rax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x173a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3daf0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x3d900
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3daba
cmpl $0x0, -0xc(%rbp)
je 0x3db65
cmpl $0x0, -0x2c(%rbp)
jne 0x3db65
movq -0x8(%rbp), %rdi
leaq 0x81cf1(%rip), %rax     # 0xbf7f8
movq 0x139e0(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rdi
leaq 0x81cda(%rip), %rax     # 0xbf7f8
movq 0x110(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rdi
leaq 0x81cc3(%rip), %rax     # 0xbf7f8
movq 0x50(%rax), %rsi
callq 0x24050
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
addq 0x48(%rax), %rsi
callq 0x24ab0
movq -0x18(%rbp), %rdi
callq 0x17510
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3dbcc
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x3d6c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3db93
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x40000, %ecx          # imm = 0x40000
movl %ecx, 0x88(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a5d0
cmpl $0x0, %eax
je 0x3dc20
jmp 0x3dc75
movl $0x2, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3dc5f
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x3d6c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3dc27
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
orl $0x40000, %ecx          # imm = 0x40000
movl %ecx, 0x88(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x3dca6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3da90
jmp 0x3dce8
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x3dce6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
callq 0x3d900
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3dcad
jmp 0x3dce8
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xa8(%rcx), %rcx
addq 0x48(%rcx), %rax
cmpq $0x0, %rax
jne 0x3dd22
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
andl $0xfffbffff, %ecx       # imm = 0xFFFBFFFF
movl %ecx, 0x88(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x1130
leaq -0x3d(%rip), %rax       # 0x2010
movq %rax, -0xa8(%rbp)
movl $0xa, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10b0
movl $0xa, %edi
callq 0x1050
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2069
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/posix_semaphore1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	sem_t sem;

	sem_init(&sem, 0, 1);

	while (1) {
		sem_wait(&sem);
		sem_post(&sem);
		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x21d0
leaq -0x30(%rbp), %rdi
callq 0x2090
leaq -0x30(%rbp), %rdi
callq 0x2140
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2fe0
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/pwhash.c
// Function: parse_digest
static int parse_digest(getopt_ctx *ctx)
{
    int l = int_of_string(getopt_parameter(ctx));
    if (l == -1) error("unspecified digest size"              );
    if (l == -2) error("digest size is not a decimal integer.");
    if (l == -3) error("digest size too big"                  );
    if (l  <  4) error("digest size too small (>= 4)"         );
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11730
movq %rax, %rdi
callq 0x11980
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x1682
leaq 0x10c29(%rip), %rdi     # 0x122a6
callq 0x11e70
cmpl $-0x2, -0xc(%rbp)
jne 0x1694
leaq 0x10c2f(%rip), %rdi     # 0x122be
callq 0x11e70
cmpl $-0x3, -0xc(%rbp)
jne 0x16a6
leaq 0x10c43(%rip), %rdi     # 0x122e4
callq 0x11e70
cmpl $0x4, -0xc(%rbp)
jge 0x16b8
leaq 0x10c45(%rip), %rdi     # 0x122f8
callq 0x11e70
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/pwhash.c
// Function: parse_nb_it
static int parse_nb_it(getopt_ctx *ctx)
{
    int l = int_of_string(getopt_parameter(ctx));
    if (l == -1) error("unspecified number of iterations"               );
    if (l == -2) error("number of iterations is not  a decimal integer.");
    if (l == -3) error("too many iterations"                            );
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11730
movq %rax, %rdi
callq 0x11980
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x1702
leaq 0x10c18(%rip), %rdi     # 0x12315
callq 0x11e70
cmpl $-0x2, -0xc(%rbp)
jne 0x1714
leaq 0x10c27(%rip), %rdi     # 0x12336
callq 0x11e70
cmpl $-0x3, -0xc(%rbp)
jne 0x1726
leaq 0x10c45(%rip), %rdi     # 0x12366
callq 0x11e70
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/pwhash.c
// Function: parse_kib
static int parse_kib(getopt_ctx *ctx)
{
    int l = int_of_string(getopt_parameter(ctx));
    if (l == -1) error("unspecified number of kilobytes"              );
    if (l == -2) error("number of kilobytes is not a decimal integer.");
    if (l == -3) error("too many kilobytes"                           );
    if (l  <  8) error("not enough kilobytes (>= 8)"                  );
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11730
movq %rax, %rdi
callq 0x11980
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x1762
leaq 0x10c1d(%rip), %rdi     # 0x1237a
callq 0x11e70
cmpl $-0x2, -0xc(%rbp)
jne 0x1774
leaq 0x10c2b(%rip), %rdi     # 0x1239a
callq 0x11e70
cmpl $-0x3, -0xc(%rbp)
jne 0x1786
leaq 0x10c47(%rip), %rdi     # 0x123c8
callq 0x11e70
cmpl $0x8, -0xc(%rbp)
jge 0x1798
leaq 0x10c48(%rip), %rdi     # 0x123db
callq 0x11e70
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/pwhash.c
// Function: parse_key
static vector parse_key(getopt_ctx *ctx) {
    vector key;
    int code = read_vector(&key, getopt_parameter(ctx));
    if (code == -1) error("unspecified key"             );
    if (code == -2) error("key too long"                );
    if (code == -3) error("key has odd number of digits");
    if (code == -4) error("key contains non-hex digits" );
    return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11730
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x11d70
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x17e6
leaq 0x10c16(%rip), %rdi     # 0x123f7
callq 0x11e70
cmpl $-0x2, -0x1c(%rbp)
jne 0x17f8
leaq 0x10c14(%rip), %rdi     # 0x12407
callq 0x11e70
cmpl $-0x3, -0x1c(%rbp)
jne 0x180a
leaq 0x10c0f(%rip), %rdi     # 0x12414
callq 0x11e70
cmpl $-0x4, -0x1c(%rbp)
jne 0x181c
leaq 0x10c1a(%rip), %rdi     # 0x12431
callq 0x11e70
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/pwhash.c
// Function: parse_ad
static vector parse_ad (getopt_ctx *ctx)
{
    vector ad;
    int code = read_vector(&ad, getopt_parameter(ctx));
    if (code == -1) error("unspecified additional data"             );
    if (code == -2) error("additional data too long"                );
    if (code == -3) error("additional data has odd number of digits");
    if (code == -4) error("additional data contains non-hex digits" );
    return ad;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11730
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x11d70
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1866
leaq 0x10bec(%rip), %rdi     # 0x1244d
callq 0x11e70
cmpl $-0x2, -0x1c(%rbp)
jne 0x1878
leaq 0x10bf6(%rip), %rdi     # 0x12469
callq 0x11e70
cmpl $-0x3, -0x1c(%rbp)
jne 0x188a
leaq 0x10bfd(%rip), %rdi     # 0x12482
callq 0x11e70
cmpl $-0x4, -0x1c(%rbp)
jne 0x189c
leaq 0x10c14(%rip), %rdi     # 0x124ab
callq 0x11e70
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/pwhash.c
// Function: parse_salt
static vector parse_salt(getopt_ctx *ctx)
{
    if (ctx->argc == 0) error("Missing salt"      );
    if (ctx->argc  < 1) error("Too many arguments");
    vector salt;
    int code = read_vector(&salt, ctx->argv[0]);
    if (code     == -2)  error("salt too long"                );
    if (code     == -3)  error("salt has odd number of digits");
    if (code     == -4)  error("salt contains non-hex digits" );
    if (salt.size <  8)  error("Salt too short"               );
    return salt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x18d1
leaq 0x10c07(%rip), %rdi     # 0x124d3
callq 0x11e70
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jge 0x18e6
leaq 0x10bff(%rip), %rdi     # 0x124e0
callq 0x11e70
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq -0x10(%rbp), %rdi
callq 0x11d70
movl %eax, -0x1c(%rbp)
cmpl $-0x2, -0x1c(%rbp)
jne 0x190f
leaq 0x10be9(%rip), %rdi     # 0x124f3
callq 0x11e70
cmpl $-0x3, -0x1c(%rbp)
jne 0x1921
leaq 0x10be5(%rip), %rdi     # 0x12501
callq 0x11e70
cmpl $-0x4, -0x1c(%rbp)
jne 0x1933
leaq 0x10bf1(%rip), %rdi     # 0x1251f
callq 0x11e70
cmpq $0x8, -0x8(%rbp)
jae 0x1946
leaq 0x10bfb(%rip), %rdi     # 0x1253c
callq 0x11e70
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x1cc0
movq $0x0, -0xa8(%rbp)
cmpq $0x4, -0xa8(%rbp)
jae 0x1c04
movq -0x18(%rbp), %rdi
movq -0xa8(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x1d70
movl %eax, %ecx
movq -0xa8(%rbp), %rax
movl %ecx, -0x70(%rbp,%rax,4)
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x1bc2
leaq -0xf0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1db0
movq $0x0, -0xf8(%rbp)
cmpq $0x4, -0xf8(%rbp)
jae 0x1c8e
movq -0x8(%rbp), %rdi
movq -0xf8(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0xf8(%rbp), %rax
movl -0xf0(%rbp,%rax,4), %esi
callq 0x22b0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0xf8(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0xf8(%rbp), %rax
movl -0xc0(%rbp,%rax,4), %esi
callq 0x22b0
movq -0xf8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xf8(%rbp)
jmp 0x1c22
leaq -0xa0(%rbp), %rdi
movl $0x88, %esi
callq 0x1b40
leaq -0xf0(%rbp), %rdi
movl $0x40, %esi
callq 0x1b40
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: chacha20_init_key
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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x113c1(%rip), %rdi     # 0x13098
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
leaq 0x113b2(%rip), %rdi     # 0x1309d
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
leaq 0x113a2(%rip), %rdi     # 0x130a2
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq 0x11392(%rip), %rdi     # 0x130a7
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq $0x0, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x1d62
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x1d70
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl %edx, 0x10(%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1d2b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: load32_le
static u32 load32_le(const u8 s[4])
{
    return (u32)s[0]
        | ((u32)s[1] <<  8)
        | ((u32)s[2] << 16)
        | ((u32)s[3] << 24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_chacha20_init
void crypto_chacha20_init(crypto_chacha_ctx *ctx,
                          const u8           key[32],
                          const u8           nonce[8])
{
    chacha20_init_key      (ctx, key);     // key
    crypto_chacha20_set_ctr(ctx, 0  );     // counter
    ctx->input[14] = load32_le(nonce + 0); // nonce
    ctx->input[15] = load32_le(nonce + 4); // nonce
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cc0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2370
movq -0x18(%rbp), %rdi
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rdi
addq $0x4, %rdi
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2665
movq -0x8(%rbp), %rax
cmpq $0x40, 0x80(%rax)
jne 0x2611
movq -0x8(%rbp), %rdi
callq 0x2670
movb $0x0, -0x29(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2631
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc520
movzbl %al, %eax
movzbl -0x29(%rbp), %ecx
xorl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x25f0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: chacha20_refill_pool
static void chacha20_refill_pool(crypto_chacha_ctx *ctx)
{
    chacha20_rounds(ctx->pool, ctx->input);
    FOR (j, 0, 16) {
        ctx->pool[j] += ctx->input[j];
    }
    ctx->pool_idx = 0;
    ctx->input[12]++;
    if (ctx->input[12] == 0) {
        ctx->input[13]++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movq -0x8(%rbp), %rsi
callq 0x1db0
movq $0x0, -0x10(%rbp)
cmpq $0x10, -0x10(%rbp)
jae 0x26c5
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
addl 0x40(%rax,%rcx,4), %edx
movl %edx, 0x40(%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2695
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x26f8
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_poly1305_init
void crypto_poly1305_init(crypto_poly1305_ctx *ctx, const u8 key[32])
{
    // Initial hash is zero
    FOR (i, 0, 5) {
        ctx->h[i] = 0;
    }
    // add 2^130 to every input block
    ctx->c[4] = 1;
    poly_clear_c(ctx);
    // load r and pad (r has some of its bits cleared)
    FOR (i, 0, 1) { ctx->r  [0] = load32_le(key           ) & 0x0fffffff; }
    FOR (i, 1, 4) { ctx->r  [i] = load32_le(key + i*4     ) & 0x0ffffffc; }
    FOR (i, 0, 4) { ctx->pad[i] = load32_le(key + i*4 + 16);              }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x5, -0x18(%rbp)
jae 0x276d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl $0x0, 0x10(%rax,%rcx,4)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2748
movq -0x8(%rbp), %rax
movl $0x1, 0x34(%rax)
movq -0x8(%rbp), %rdi
callq 0x2850
movq $0x0, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jae 0x27b5
movq -0x10(%rbp), %rdi
callq 0x1d70
movl %eax, %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2789
movq $0x1, -0x28(%rbp)
cmpq $0x4, -0x28(%rbp)
jae 0x27f9
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x1d70
movl %eax, %edx
andl $0xffffffc, %edx        # imm = 0xFFFFFFC
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x27bd
movq $0x0, -0x30(%rbp)
cmpq $0x4, -0x30(%rbp)
jae 0x283c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
addq $0x10, %rdi
callq 0x1d70
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %edx, 0x38(%rax,%rcx,4)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2801
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: poly_clear_c
static void poly_clear_c(crypto_poly1305_ctx *ctx)
{
    ctx->c[0]  = 0;
    ctx->c[1]  = 0;
    ctx->c[2]  = 0;
    ctx->c[3]  = 0;
    ctx->c_idx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_poly1305_update
void crypto_poly1305_update(crypto_poly1305_ctx *ctx,
                            const u8 *message, size_t message_size)
{
    // Align ourselves with block boundaries
    size_t align = MIN(ALIGN(ctx->c_idx, 16), message_size);
    poly_update(ctx, message, align);
    message      += align;
    message_size -= align;

    // Process the message block by block
    size_t nb_blocks = message_size >> 4;
    FOR (i, 0, nb_blocks) {
        ctx->c[0] = load32_le(message +  0);
        ctx->c[1] = load32_le(message +  4);
        ctx->c[2] = load32_le(message +  8);
        ctx->c[3] = load32_le(message + 12);
        poly_block(ctx);
        message += 16;
    }
    if (nb_blocks > 0) {
        poly_clear_c(ctx);
    }
    message_size &= 15;

    // remaining bytes
    poly_update(ctx, message, message_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
andq $0xf, %rax
cmpq -0x18(%rbp), %rax
ja 0x28e8
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
andq $0xf, %rax
movq %rax, -0x38(%rbp)
jmp 0x28f0
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x29f0
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x29bc
movq -0x10(%rbp), %rdi
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
callq 0x1d70
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x2a60
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2938
cmpq $0x0, -0x28(%rbp)
jbe 0x29cc
movq -0x8(%rbp), %rdi
callq 0x2850
movq -0x18(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x29f0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: poly_update
static void poly_update(crypto_poly1305_ctx *ctx,
                        const u8 *message, size_t message_size)
{
    FOR (i, 0, message_size) {
        poly_take_input(ctx, message[i]);
        if (ctx->c_idx == 16) {
            poly_block(ctx);
            poly_clear_c(ctx);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2a58
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x2f30
movq -0x8(%rbp), %rax
cmpq $0x10, 0x48(%rax)
jne 0x2a48
movq -0x8(%rbp), %rdi
callq 0x2a60
movq -0x8(%rbp), %rdi
callq 0x2850
jmp 0x2a4a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2a0c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: poly_take_input
static void poly_take_input(crypto_poly1305_ctx *ctx, u8 input)
{
    size_t word = ctx->c_idx >> 2;
    size_t byte = ctx->c_idx & 3;
    ctx->c[word] |= (u32)input << (byte * 8);
    ctx->c_idx++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
shrq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
andq $0x3, %rax
movq %rax, -0x20(%rbp)
movzbl -0x9(%rbp), %edx
movq -0x20(%rbp), %rax
shlq $0x3, %rax
movl %eax, %ecx
shll %cl, %edx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
orl 0x24(%rax,%rcx,4), %edx
movl %edx, 0x24(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_blake2b_general_init
void crypto_blake2b_general_init(crypto_blake2b_ctx *ctx, size_t hash_size,
                                 const u8           *key, size_t key_size)
{
    // initial hash
    FOR (i, 0, 8) {
        ctx->hash[i] = iv[i];
    }
    ctx->hash[0] ^= 0x01010000 ^ (key_size << 8) ^ hash_size;

    ctx->input_offset[0] = 0;         // begining of the input, no offset
    ctx->input_offset[1] = 0;         // begining of the input, no offset
    ctx->hash_size       = hash_size; // remember the hash size we want
    ctx->input_idx       = 0;

    // if there is a key, the first block is that key (padded with zeroes)
    if (key_size > 0) {
        crypto_blake2b_update(ctx, key ,       key_size);
        crypto_blake2b_update(ctx, zero, 128 - key_size);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x8, -0x28(%rbp)
jae 0x3030
movq -0x28(%rbp), %rcx
leaq 0xf53e(%rip), %rax      # 0x12550
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3000
movq -0x20(%rbp), %rcx
shlq $0x8, %rcx
xorq $0x1010000, %rcx        # imm = 0x1010000
xorq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xd0(%rax)
cmpq $0x0, -0x20(%rbp)
jbe 0x30b4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x30c0
movq -0x8(%rbp), %rdi
movl $0x80, %edx
subq -0x20(%rbp), %rdx
leaq 0xf4e1(%rip), %rsi      # 0x12590
callq 0x30c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_blake2b_update
void crypto_blake2b_update(crypto_blake2b_ctx *ctx,
                           const u8 *message, size_t message_size)
{
    // Align ourselves with block boundaries
    size_t align = MIN(ALIGN(ctx->input_idx, 128), message_size);
    blake2b_update(ctx, message, align);
    message      += align;
    message_size -= align;

    // Process the message block by block
    FOR (i, 0, message_size >> 7) { // number of blocks
        blake2b_end_block(ctx);
        FOR (j, 0, 16) {
            ctx->input[j] = load64_le(message + j*8);
        }
        message += 128;
        ctx->input_idx = 128;
    }
    message_size &= 127;

    // remaining bytes
    blake2b_update(ctx, message, message_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
andq $0x7f, %rax
cmpq -0x18(%rbp), %rax
ja 0x310e
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
andq $0x7f, %rax
movq %rax, -0x38(%rbp)
jmp 0x3116
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3230
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
shrq $0x7, %rcx
cmpq %rcx, %rax
jae 0x31db
movq -0x8(%rbp), %rdi
callq 0x32b0
movq $0x0, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jae 0x31ad
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x3300
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, 0x50(%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3174
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x80, 0xd0(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3152
movq -0x18(%rbp), %rax
andq $0x7f, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3230
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: blake2b_update
static void blake2b_update(crypto_blake2b_ctx *ctx,
                           const u8 *message, size_t message_size)
{
    FOR (i, 0, message_size) {
        blake2b_end_block(ctx);
        blake2b_set_input(ctx, message[i], ctx->input_idx);
        ctx->input_idx++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x32a5
movq -0x8(%rbp), %rdi
callq 0x32b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x8(%rbp), %rcx
movq 0xd0(%rcx), %rdx
movzbl %al, %esi
callq 0x3470
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xd0(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x324c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: blake2b_end_block
static void blake2b_end_block(crypto_blake2b_ctx *ctx)
{
    if (ctx->input_idx == 128) {  // If buffer is full,
        blake2b_incr(ctx);        // update the input offset
        blake2b_compress(ctx, 0); // and compress the (not last) block
        ctx->input_idx = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x80, 0xd0(%rax)
jne 0x32f0
movq -0x8(%rbp), %rdi
callq 0x3500
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3550
movq -0x8(%rbp), %rax
movq $0x0, 0xd0(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)