LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x29e0b
movq %rax, %r12
testq %rax, %rax
jne 0x2c570
movq %r14, %rdi
callq 0x29e31
movq %rax, %r12
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
jne 0x2c594
leaq 0x3d84d(%rip), %rdi     # 0x69dd0
xorl %esi, %esi
callq 0x1464a
movq %rax, %rdi
movq %rax, 0xa8(%rbx)
movq (%r12), %rsi
movq %r12, %rdx
callq 0x148e3
xorl %ebp, %ebp
testl %eax, %eax
jne 0x2c5e6
cmpq $0x0, 0x60(%r12)
jne 0x2c5b8
callq 0x12aec
movq %rax, 0x60(%r12)
pushq $0x30
popq %rdi
callq 0x1ab29
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
andq $0x0, 0x10(%rax)
fldz
fstpt 0x20(%rax)
movq 0x60(%r12), %rdi
movq %rax, %rsi
callq 0x12bac
testq %rax, %rax
je 0x2c643
pushq $0x1
popq %rbp
leaq 0x3e1ab(%rip), %r15     # 0x6a798
movq 0x139e0(%r15), %rsi
movq %rbx, %rdi
callq 0x1c8e7
movq 0x108(%r15), %rsi
movq %rbx, %rdi
callq 0x1c8e7
movq %r14, %rdi
callq 0x2c661
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1d103
movq 0xa8(%rbx), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x1d00a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e2a(%rip), %rdi     # 0x52474
leaq 0x25e50(%rip), %rsi     # 0x524a1
pushq $0x41
popq %rdx
callq 0x240ca
pushq $0x1
popq %rdi
callq 0x12120
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
xorl %r15d, %r15d
testq %rdi, %rdi
je 0x2c733
movq %r14, %rsi
callq 0x14ca3
testq %rax, %rax
je 0x2c733
movq 0x8(%rax), %r13
movq 0xa8(%rbx), %rdi
movq %rax, %rsi
callq 0x14cab
movq 0x60(%r13), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x12d0c
movq %r15, %rdi
callq 0x12d26
testq %rax, %rax
je 0x2c71a
movq 0x10(%rax), %r12
cmpq %rbx, (%r12)
jne 0x2c6ef
movq 0x60(%r13), %rdi
movq %rax, %rsi
callq 0x12c88
movq %r12, %rdi
callq 0x1ac81
movq 0x60(%r13), %rdi
pushq $0x1
popq %r15
cmpq $0x0, 0x28(%rdi)
jne 0x2c733
callq 0x12b0a
andq $0x0, 0x60(%r13)
testl %ebp, %ebp
je 0x2c78b
leaq 0x3e05a(%rip), %r12     # 0x6a798
movq 0x139e0(%r12), %rsi
movq %rbx, %rdi
callq 0x1c8e7
movq 0x110(%r12), %rsi
movq %rbx, %rdi
callq 0x1c8e7
movq %r14, %rdi
callq 0x2c661
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1d103
movq 0xa8(%rbx), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %rbx, %rdi
callq 0x1d00a
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r15
movq 0xa8(%rdi), %rdi
callq 0x14f4c
movq %rax, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x14f5b
testq %rax, %rax
je 0x2c7d9
movq (%rax), %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x2c699
addl %eax, %ebx
jmp 0x2c7bb
testl %ebp, %ebp
je 0x2c82c
testl %ebx, %ebx
jne 0x2c82c
leaq 0x3dfb0(%rip), %r12     # 0x6a798
movq 0x139e0(%r12), %rsi
movq %r15, %rdi
callq 0x1c8e7
movq 0x110(%r12), %rsi
movq %r15, %rdi
callq 0x1c8e7
movq 0x50(%r12), %rsi
movq %r15, %rdi
callq 0x1c8e7
movq 0xa8(%r15), %rax
movq 0x48(%rax), %rsi
addq 0x28(%rax), %rsi
movq %r15, %rdi
callq 0x1d00a
movq %r14, %rdi
callq 0x1501c
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movq %r14, %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x2c873
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2c544
incq %r15
jmp 0x2c84e
orb $0x4, 0x8a(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x203c6
testl %eax, %eax
jne 0x2c8ce
pushq $0x2
popq %r14
movslq 0x28(%rbx), %rax
cmpq %rax, %r14
jge 0x2c8c7
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
movq %rbx, %rdi
callq 0x2c544
incq %r14
jmp 0x2c8a1
orb $0x4, 0x8a(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rdi), %eax
cmpl $0x1, %eax
jne 0x2c90d
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2c79d
movq 0xa8(%rbx), %rax
movq 0x28(%rax), %rcx
addq 0x48(%rax), %rcx
jne 0x2c908
andb $-0x5, 0x8a(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %r14
pushq $0x1
popq %rbp
cltq
cmpq %rax, %r14
jge 0x2c8f0
movq 0x30(%rbx), %rax
movq (%rax,%r14,8), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x2c699
incq %r14
movl 0x28(%rbx), %eax
jmp 0x2c914
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1140
leaq -0x2a(%rip), %rax       # 0x1bb0
movq %rax, -0x8(%r14)
pushq $0xa
popq %rbp
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
xorl %edx, %edx
callq 0x10c0
movl %ebp, %edi
callq 0x1050
incq (%rbx)
jmp 0x1bef
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x21e0
movq %r14, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2150
incq (%rbx)
jmp 0x2b5c
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: x32
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:
movdqu (%rdi), %xmm0
movdqu 0x10(%rdi), %xmm1
movdqu (%rsi), %xmm2
pxor %xmm0, %xmm2
movdqu 0x10(%rsi), %xmm0
pxor %xmm1, %xmm0
por %xmm2, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
por %xmm0, %xmm1
movq %xmm1, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
callq 0x17c1
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1774
movl (%r14,%rax,4), %ecx
movl %ecx, 0x70(%rsp,%rax,4)
incq %rax
jmp 0x1761
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x17e0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x179c
movl (%rsp,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
movl 0x30(%rsp,%rax,4), %ecx
movl %ecx, 0x10(%rbx,%rax,4)
incq %rax
jmp 0x1783
leaq 0x40(%rsp), %rdi
movl $0x88, %esi
callq 0x1734
movq %rsp, %rdi
pushq $0x40
popq %rsi
callq 0x1734
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x17c1
andq $0x0, 0x30(%r14)
movq $0x40, 0x80(%r14)
movl (%rbx), %eax
movl %eax, 0x38(%r14)
movl 0x4(%rbx), %eax
movl %eax, 0x3c(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %ebp, %ebp
subl 0x80(%rdi), %ebp
andl $0x3f, %ebp
cmpq %rcx, %rbp
cmovaeq %rcx, %rbp
movq %rbp, %rcx
callq 0x1b54
movq %r12, %rax
addq %rbp, %r12
testq %rax, %rax
cmoveq %rax, %r12
addq %rbp, %r14
subq %rbp, %r13
movq %r13, %rbp
shrq $0x6, %r13
cmpq %r13, %rbx
je 0x1b35
movq %r15, %rdi
callq 0x1bd4
xorl %eax, %eax
testq %r12, %r12
jne 0x1b11
cmpq $0x40, %rax
je 0x1b1f
movl 0x40(%r15,%rax), %ecx
movl %ecx, (%r14,%rax)
addq $0x4, %rax
jmp 0x1aeb
movl 0x40(%r15,%rax), %ecx
xorl (%r12,%rax), %ecx
movl %ecx, (%r14,%rax)
addq $0x4, %rax
cmpq $0x40, %rax
jne 0x1b00
addq %rax, %r12
addq %rax, %r14
jmp 0x1b25
addq %rax, %r14
xorl %r12d, %r12d
movq $0x40, 0x80(%r15)
incq %rbx
jmp 0x1ad7
andl $0x3f, %ebp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b54
// File: /workspace/github_c_makefile_star2_O2/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 %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 %r13, %rbx
je 0x1bca
cmpq $0x40, 0x80(%r12)
jne 0x1b84
movq %r12, %rdi
callq 0x1bd4
testq %r15, %r15
je 0x1b91
movb (%r15), %al
incq %r15
jmp 0x1b96
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
jmp 0x1b6c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17e0
xorl %eax, %eax
cmpq $0x10, %rax
je 0x1c00
movl -0x40(%r14,%rax,4), %ecx
addl %ecx, (%r14,%rax,4)
incq %rax
jmp 0x1bec
andq $0x0, 0x80(%rbx)
incl 0x30(%rbx)
jne 0x1c10
incl 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x4
popq %rax
cmpq $0x9, %rax
je 0x1c34
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0x1c25
movl $0x1, 0x34(%rdi)
andq $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movl $0xfffffff, %eax        # imm = 0xFFFFFFF
andl (%rsi), %eax
movl %eax, (%rdi)
pushq $0x1
popq %rax
movl $0xffffffc, %ecx        # imm = 0xFFFFFFC
cmpq $0x4, %rax
je 0x1c6b
movl (%rsi,%rax,4), %edx
andl %ecx, %edx
movl %edx, (%rdi,%rax,4)
incq %rax
jmp 0x1c58
xorl %eax, %eax
cmpq $0x4, %rax
je 0x1c80
movl 0x10(%rsi,%rax,4), %ecx
movl %ecx, 0x38(%rdi,%rax,4)
incq %rax
jmp 0x1c6d
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
subl 0x48(%rdi), %r12d
andl $0xf, %r12d
cmpq %rdx, %r12
cmovaeq %rdx, %r12
movq %r12, %rdx
callq 0x1d1b
addq %r12, %r14
subq %r12, %rbx
movq %rbx, %r13
shrq $0x4, %r13
leaq 0x24(%r15), %r12
subq $0x1, %r13
jb 0x1cf1
movl (%r14), %eax
movl %eax, 0x24(%r15)
movl 0x4(%r14), %eax
movl %eax, 0x28(%r15)
movl 0x8(%r14), %eax
movl %eax, 0x2c(%r15)
movl 0xc(%r14), %eax
movl %eax, 0x30(%r15)
movq %r15, %rdi
callq 0x1d71
addq $0x10, %r14
jmp 0x1cbe
cmpq $0x10, %rbx
jb 0x1d04
andq $0x0, 0x48(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
andl $0xf, %ebx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1d1b
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x24(%rdi), %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x1d67
movzbl (%r14,%r13), %esi
movq %r15, %rdi
callq 0x200a
cmpq $0x10, 0x48(%r15)
jne 0x1d62
movq %r15, %rdi
callq 0x1d71
andq $0x0, 0x48(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
incq %r13
jmp 0x1d34
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_poly1305_final
void crypto_poly1305_final(crypto_poly1305_ctx *ctx, u8 mac[16])
{
    // Process the last block (if any)
    if (ctx->c_idx != 0) {
        // move the final 1 according to remaining input length
        // (We may add less than 2^130 to the last input block)
        ctx->c[4] = 0;
        poly_take_input(ctx, 1);
        // one last hash update
        poly_block(ctx);
    }

    // check if we should subtract 2^130-5 by performing the
    // corresponding carry propagation.
    const u64 u0 = (u64)5     + ctx->h[0]; // <= 1_00000004
    const u64 u1 = (u0 >> 32) + ctx->h[1]; // <= 1_00000000
    const u64 u2 = (u1 >> 32) + ctx->h[2]; // <= 1_00000000
    const u64 u3 = (u2 >> 32) + ctx->h[3]; // <= 1_00000000
    const u64 u4 = (u3 >> 32) + ctx->h[4]; // <=          5
    // u4 indicates how many times we should subtract 2^130-5 (0 or 1)

    // h + pad, minus 2^130-5 if u4 exceeds 3
    const u64 uu0 = (u4 >> 2) * 5 + ctx->h[0] + ctx->pad[0]; // <= 2_00000003
    const u64 uu1 = (uu0 >> 32)   + ctx->h[1] + ctx->pad[1]; // <= 2_00000000
    const u64 uu2 = (uu1 >> 32)   + ctx->h[2] + ctx->pad[2]; // <= 2_00000000
    const u64 uu3 = (uu2 >> 32)   + ctx->h[3] + ctx->pad[3]; // <= 2_00000000

    store32_le(mac     , (u32)uu0);
    store32_le(mac +  4, (u32)uu1);
    store32_le(mac +  8, (u32)uu2);
    store32_le(mac + 12, (u32)uu3);

    WIPE_CTX(ctx);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x1f36
andl $0x0, 0x34(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x200a
movq %rbx, %rdi
callq 0x1d71
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %r8d
leaq 0x5(%rax), %rcx
shrq $0x20, %rcx
addq %r8, %rcx
shrq $0x20, %rcx
movl 0x18(%rbx), %r9d
addq %r9, %rcx
shrq $0x20, %rcx
movl 0x1c(%rbx), %esi
addq %rsi, %rcx
shrq $0x20, %rcx
movl 0x20(%rbx), %edx
addq %rcx, %rdx
shrq $0x2, %rdx
leaq (%rdx,%rdx,4), %rcx
movl 0x38(%rbx), %edx
addq %rax, %rdx
addq %rcx, %rdx
movl 0x3c(%rbx), %ecx
movl 0x40(%rbx), %eax
movl 0x44(%rbx), %edi
movb %dl, (%rbp)
movb %dh, 0x1(%rbp)
movl %edx, %r10d
shrl $0x10, %r10d
movb %r10b, 0x2(%rbp)
movq %rdx, %r10
shrl $0x18, %edx
movb %dl, 0x3(%rbp)
addq %r8, %rcx
shrq $0x20, %r10
addq %r10, %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
addq %r9, %rax
addq %rdx, %rax
movb %cl, 0x4(%rbp)
movb %ch, 0x5(%rbp)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, 0x6(%rbp)
shrl $0x18, %ecx
movb %cl, 0x7(%rbp)
movq %rax, %rcx
movb %al, 0x8(%rbp)
movb %ah, 0x9(%rbp)
movl %eax, %edx
shrl $0x10, %edx
movb %dl, 0xa(%rbp)
shrl $0x18, %eax
movb %al, 0xb(%rbp)
shrq $0x20, %rcx
addl %esi, %edi
addl %edi, %ecx
movb %cl, 0xc(%rbp)
movb %ch, 0xd(%rbp)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0xe(%rbp)
shrl $0x18, %ecx
movb %cl, 0xf(%rbp)
pushq $0x50
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1734
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x753a(%rip), %rcx      # 0x95c0
cmpq $0x40, %rax
je 0x209a
movq (%rax,%rcx), %rdi
movq %rdi, (%r14,%rax)
addq $0x8, %rax
jmp 0x2086
movq %rbx, %rax
shlq $0x8, %rax
xorq (%r14), %rax
xorq %rsi, %rax
xorq $0x1010000, %rax        # imm = 0x1010000
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
movq %rsi, 0xd8(%r14)
andq $0x0, 0xd0(%r14)
testq %rbx, %rbx
je 0x20f8
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x2100
movl $0x80, %edx
subq %rbx, %rdx
leaq 0x7517(%rip), %rsi      # 0x9600
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
subl 0xd0(%rdi), %r12d
andl $0x7f, %r12d
cmpq %rdx, %r12
cmovaeq %rdx, %r12
movq %r12, %rdx
callq 0x21a0
addq %r12, %r14
subq %r12, %rbx
movq %rbx, %r12
shrq $0x7, %r12
movl $0x80, %ebp
cmpq %r12, %r13
je 0x2178
movq %r15, %rdi
callq 0x21ed
xorl %eax, %eax
cmpq $0x10, %rax
je 0x2169
movq (%r14,%rax,8), %rcx
movq %rcx, 0x50(%r15,%rax,8)
incq %rax
jmp 0x2155
addq %rbp, %r14
movq %rbp, 0xd0(%r15)
incq %r13
jmp 0x2146
andl $0x7f, %ebx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x21e1
movq %r15, %rdi
callq 0x21ed
movzbl (%r14,%r12), %esi
movq 0xd0(%r15), %rdx
movq %r15, %rdi
callq 0x22db
incq 0xd0(%r15)
incq %r12
jmp 0x21b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x80, 0xd0(%rdi)
jne 0x2216
pushq %rbx
movq %rdi, %rbx
callq 0x230b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x231d
andq $0x0, 0xd0(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_blake2b_final
void crypto_blake2b_final(crypto_blake2b_ctx *ctx, u8 *hash)
{
    // Pad the end of the block with zeroes
    FOR (i, ctx->input_idx, 128) {
        blake2b_set_input(ctx, 0, i);
    }
    blake2b_incr(ctx);         // update the input offset
    blake2b_compress(ctx, -1); // compress the last block
    size_t nb_words = ctx->hash_size >> 3;
    FOR (i, 0, nb_words) {
        store64_le(hash + i*8, ctx->hash[i]);
    }
    FOR (i, nb_words * 8, ctx->hash_size) {
        hash[i] = (ctx->hash[i >> 3] >> (8 * (i & 7))) & 0xff;
    }
    WIPE_CTX(ctx);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xd0(%rdi), %r15
movq %rbx, %rdi
cmpq $0x80, %r15
jae 0x224a
xorl %esi, %esi
movq %r15, %rdx
callq 0x22db
incq %r15
jmp 0x222f
callq 0x230b
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x231d
movq 0xd8(%rbx), %r12
movq %r12, %r13
shrq $0x3, %r13
xorl %ebp, %ebp
movq %r14, %r15
cmpq %rbp, %r13
je 0x2287
movq (%rbx,%rbp,8), %rsi
movq %r15, %rdi
callq 0x3991
incq %rbp
addq $0x8, %r15
jmp 0x226d
movq %r12, %rax
andq $-0x8, %rax
shlq $0x3, %r12
andq $-0x40, %r12
cmpq 0xd8(%rbx), %rax
jae 0x22c0
movq %rax, %rcx
andq $-0x8, %rcx
movq (%rbx,%rcx), %rdx
movl %r12d, %ecx
andb $0x38, %cl
shrq %cl, %rdx
movb %dl, (%r14,%rax)
incq %rax
addq $0x8, %r12
jmp 0x2296
movl $0xe0, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1734
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: blake2b_set_input
static void blake2b_set_input(crypto_blake2b_ctx *ctx, u8 input, size_t index)
{
    if (index == 0) {
        FOR (i, 0, 16) {
            ctx->input[i] = 0;
        }
    }
    size_t word = index >> 3;
    size_t byte = index & 7;
    ctx->input[word] |= (u64)input << (byte << 3);

}

// Assembly:
testq %rdx, %rdx
je 0x22f8
movzbl %sil, %eax
leal (,%rdx,8), %ecx
shlq %cl, %rax
andq $-0x8, %rdx
orq %rax, 0x50(%rdi,%rdx)
retq
xorl %eax, %eax
cmpq $0x10, %rax
je 0x22e0
andq $0x0, 0x50(%rdi,%rax,8)
incq %rax
jmp 0x22fa
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: extended_hash
static void extended_hash(u8       *digest, u32 digest_size,
                          const u8 *input , u32 input_size)
{
    crypto_blake2b_ctx ctx;
    crypto_blake2b_general_init(&ctx, MIN(digest_size, 64), 0, 0);
    blake_update_32            (&ctx, digest_size);
    crypto_blake2b_update      (&ctx, input, input_size);
    crypto_blake2b_final       (&ctx, digest);

    if (digest_size > 64) {
        // the conversion to u64 avoids integer overflow on
        // ludicrously big hash sizes.
        u32 r   = (((u64)digest_size + 31) >> 5) - 2;
        u32 i   =  1;
        u32 in  =  0;
        u32 out = 32;
        while (i < r) {
            // Input and output overlap. This is intentional
            crypto_blake2b(digest + out, digest + in, 64);
            i   +=  1;
            in  += 32;
            out += 32;
        }
        crypto_blake2b_general(digest + out, digest_size - (32 * r),
                               0, 0, // no key
                               digest + in , 64);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x40, %esi
pushq $0x40
popq %rsi
cmovbl %ebx, %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2073
movq %r12, %rdi
movl %ebx, %esi
callq 0x3e65
movl %ebp, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movq %r12, %rdi
movq %r14, %rsi
callq 0x2217
cmpl $0x41, %ebx
jb 0x3f3e
movl %ebx, %r13d
addq $0x1f, %r13
shrq $0x5, %r13
leal -0x2(%r13), %ebp
addl $-0x3, %r13d
pushq $0x40
popq %r15
subl $0x1, %r13d
jb 0x3f22
leaq 0x20(%r14), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x39e1
movq %r12, %r14
jmp 0x3f05
shll $0x5, %ebp
subl %ebp, %ebx
leaq 0x20(%r14), %rdi
pushq $0x40
popq %r9
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r8
callq 0x3995
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: fe_cswap
static void fe_cswap(fe f, fe g, int b)
{
    FOR (i, 0, 10) {
        i32 x = (f[i] ^ g[i]) & -b;
        f[i] = f[i] ^ x;
        g[i] = g[i] ^ x;
    }
}

// Assembly:
negl %edx
xorl %eax, %eax
cmpq $0xa, %rax
je 0x44da
movl (%rdi,%rax,4), %ecx
movl (%rsi,%rax,4), %r8d
xorl %ecx, %r8d
andl %edx, %r8d
xorl %r8d, %ecx
movl %ecx, (%rdi,%rax,4)
xorl %r8d, (%rsi,%rax,4)
incq %rax
jmp 0x44b8
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_sign_public_key
void crypto_sign_public_key(u8       public_key[32],
                            const u8 secret_key[32])
{
    u8 a[64];
    HASH(a, secret_key, 32);
    trim_scalar(a);
    ge A;
    ge_scalarmult_base(&A, a);
    ge_tobytes(public_key, &A);
    WIPE_BUFFER(a);
    WIPE_CTX(&A);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x20
popq %rdx
movq %r14, %rdi
callq 0x39e1
andb $-0x8, (%r14)
movb 0x1f(%r14), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%r14)
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x575a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5ace
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x1734
movl $0xa0, %esi
movq %r15, %rdi
callq 0x1734
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_tobytes
static void ge_tobytes(u8 s[32], const ge *h)
{
    fe recip, x, y;
    fe_invert(recip, h->Z);
    fe_mul(x, h->X, recip);
    fe_mul(y, h->Y, recip);
    fe_tobytes(s, y);
    s[31] ^= fe_isnegative(x) << 7;

    WIPE_BUFFER(recip);
    WIPE_BUFFER(x);
    WIPE_BUFFER(y);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r13
movq %rdi, %rbx
addq $0x50, %rsi
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x51dc
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4509
addq $0x28, %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x4509
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5453
movq %r15, %rdi
callq 0x76ba
shlb $0x7, %al
xorb %al, 0x1f(%rbx)
pushq $0x28
popq %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1734
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1734
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1734
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_sign_init_first_pass
void crypto_sign_init_first_pass(crypto_sign_ctx *ctx,
                                 const u8  secret_key[32],
                                 const u8  public_key[32])
{
    u8 *a      = ctx->buf;
    u8 *prefix = ctx->buf + 32;
    HASH(a, secret_key, 32);
    trim_scalar(a);

    if (public_key == 0) {
        crypto_sign_public_key(ctx->pk, secret_key);
    } else {
        FOR (i, 0, 32) {
            ctx->pk[i] = public_key[i];
        }
    }

    // Constructs the "random" nonce from the secret key and message.
    // An actual random number would work just fine, and would save us
    // the trouble of hashing the message twice.  If we did that
    // however, the user could fuck it up and reuse the nonce.
    HASH_INIT  (&ctx->hash);
    HASH_UPDATE(&ctx->hash, prefix , 32);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0xe0, %rdi
pushq $0x20
popq %rdx
callq 0x39e1
andb $-0x8, 0xe0(%rbx)
movb 0xff(%rbx), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0xff(%rbx)
leaq 0x140(%rbx), %rdi
testq %r14, %r14
je 0x5bbf
xorl %eax, %eax
cmpq $0x20, %rax
je 0x5bc7
movb (%r14,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
jmp 0x5bad
movq %r15, %rsi
callq 0x56ed
leaq 0x100(%rbx), %r14
movq %rbx, %rdi
callq 0x2194
pushq $0x20
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_sign_init_second_pass
void crypto_sign_init_second_pass(crypto_sign_ctx *ctx)
{
    u8 *r        = ctx->buf + 32;
    u8 *half_sig = ctx->buf + 64;
    HASH_FINAL(&ctx->hash, r);
    reduce(r);

    // first half of the signature = "random" nonce times basepoint
    ge R;
    ge_scalarmult_base(&R, r);
    ge_tobytes(half_sig, &R);
    WIPE_CTX(&R);

    // Hash R, the public key, and the message together.
    // It cannot be done in parallel with the first hash.
    HASH_INIT  (&ctx->hash);
    HASH_UPDATE(&ctx->hash, half_sig, 32);
    HASH_UPDATE(&ctx->hash, ctx->pk , 32);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r15
leaq 0x120(%rdi), %r14
movq %r15, %rsi
callq 0x2217
movq %r15, %rdi
callq 0x5c80
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x575a
movq %r14, %rdi
movq %r12, %rsi
callq 0x5ace
movl $0xa0, %esi
movq %r12, %rdi
callq 0x1734
movq %rbx, %rdi
callq 0x2194
pushq $0x20
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2100
leaq 0x140(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2100
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: reduce
static void reduce(u8 r[64])
{
    i64 x[64];
    FOR (i, 0, 64) {
        x[i] = (u64) r[i];
        r[i] = 0;
    }
    modL(r, x);
    WIPE_BUFFER(x);
}

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
xorl %eax, %eax
cmpq $0x40, %rax
je 0x5ca1
movzbl (%rdi,%rax), %ecx
movq %rcx, (%rsp,%rax,8)
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x5c8a
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x76e8
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
callq 0x1734
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_sign_final
void crypto_sign_final(crypto_sign_ctx *ctx, u8 signature[64])
{
    u8 *a        = ctx->buf;
    u8 *r        = ctx->buf + 32;
    u8 *half_sig = ctx->buf + 64;
    u8 h_ram[64];
    HASH_FINAL(&ctx->hash, h_ram);
    reduce(h_ram);  // reduce the hash modulo L
    FOR (i, 0, 32) {
        signature[i] = half_sig[i];
    }
    mul_add(signature + 32, h_ram, a, r); // s = h_ram * a + r
    WIPE_CTX(ctx);
    WIPE_BUFFER(h_ram);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rsi
callq 0x2217
movq %r15, %rdi
callq 0x5c80
xorl %eax, %eax
cmpq $0x20, %rax
je 0x5cfc
movb 0x120(%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x5ce6
leaq 0xe0(%rbx), %rdx
leaq 0x100(%rbx), %rcx
addq $0x20, %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d3e
movl $0x160, %esi            # imm = 0x160
movq %rbx, %rdi
callq 0x1734
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x1734
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: mul_add
static void mul_add(u8 r[32], const u8 a[32], const u8 b[32], const u8 c[32])
{
    i64 s[64];
    FOR (i,  0, 32) { s[i] = (u64) c[i]; }
    FOR (i, 32, 64) { s[i] = 0;          }
    FOR (i,  0, 32) {
        FOR (j, 0, 32) {
            s[i+j] += a[i] * (u64) b[j];
        }
    }
    modL(r, s);
    WIPE_BUFFER(s);
}

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
xorl %eax, %eax
cmpq $0x20, %rax
je 0x5d5c
movzbl (%rcx,%rax), %r8d
movq %r8, (%rsp,%rax,8)
incq %rax
jmp 0x5d48
pushq $0x20
popq %rax
cmpq $0x40, %rax
je 0x5d6f
andq $0x0, (%rsp,%rax,8)
incq %rax
jmp 0x5d5f
movq %rsp, %rax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x5da3
movzbl (%rsi,%rcx), %r8d
xorl %r9d, %r9d
cmpq $0x20, %r9
je 0x5d9a
movzbl (%rdx,%r9), %r10d
imulq %r8, %r10
addq %r10, (%rax,%r9,8)
incq %r9
jmp 0x5d82
incq %rcx
addq $0x8, %rax
jmp 0x5d74
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x76e8
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
callq 0x1734
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_sign
void crypto_sign(u8        signature[64],
                 const u8  secret_key[32],
                 const u8  public_key[32],
                 const u8 *message, size_t message_size)
{
    crypto_sign_ctx ctx;
    crypto_sign_init_first_pass (&ctx, secret_key, public_key);
    crypto_sign_update          (&ctx, message, message_size);
    crypto_sign_init_second_pass(&ctx);
    crypto_sign_update          (&ctx, message, message_size);
    crypto_sign_final           (&ctx, signature);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x5b6b
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2100
movq %r12, %rdi
callq 0x5bee
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2100
movq %r12, %rdi
movq %r15, %rsi
callq 0x5cc2
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_check_init
void crypto_check_init(crypto_check_ctx *ctx,
                      const u8 signature[64],
                      const u8 public_key[32])
{
    FOR (i, 0, 64) { ctx->sig[i] = signature [i]; }
    FOR (i, 0, 32) { ctx->pk [i] = public_key[i]; }
    HASH_INIT  (&ctx->hash);
    HASH_UPDATE(&ctx->hash, signature , 32);
    HASH_UPDATE(&ctx->hash, public_key, 32);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
cmpq $0x40, %rax
je 0x5e50
movb (%r15,%rax), %cl
movb %cl, 0xe0(%r14,%rax)
incq %rax
jmp 0x5e39
xorl %eax, %eax
cmpq $0x20, %rax
je 0x5e68
movb (%rbx,%rax), %cl
movb %cl, 0x120(%r14,%rax)
incq %rax
jmp 0x5e52
movq %r14, %rdi
callq 0x2194
pushq $0x20
popq %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2100
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_key_exchange
int crypto_key_exchange(u8       shared_key[32],
                        const u8 your_secret_key [32],
                        const u8 their_public_key[32])
{
    u8 raw_shared_secret[32];
    int status = crypto_x25519(raw_shared_secret,
                               your_secret_key, their_public_key);
    crypto_chacha20_H(shared_key, raw_shared_secret, zero);
    WIPE_BUFFER(raw_shared_secret);
    return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3fc0
movl %eax, %ebp
leaq 0x2fc1(%rip), %rdx      # 0x9600
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1745
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1734
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_lock_init
void crypto_lock_init(crypto_lock_ctx *ctx,
                      const u8 key[32], const u8 nonce[24])
{
    u8 auth_key[64]; // "Wasting" the whole Chacha block is faster
    ctx->ad_phase     = 1;
    ctx->ad_size      = 0;
    ctx->message_size = 0;
    crypto_chacha20_x_init(&ctx->chacha, key, nonce);
    crypto_chacha20_stream(&ctx->chacha, auth_key, 64);
    crypto_poly1305_init  (&ctx->poly  , auth_key);
    WIPE_BUFFER(auth_key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl $0x1, 0xe8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
callq 0x1a49
movq %rsp, %r14
pushq $0x40
popq %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1c18
addq $0x88, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c22
movq %r14, %rdi
movq %r15, %rsi
callq 0x1734
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_lock_final
void crypto_lock_final(crypto_lock_ctx *ctx, u8 mac[16])
{
    lock_ad_padding(ctx);
    u8 sizes[16]; // Not secret, not wiped
    store64_le(sizes + 0, ctx->ad_size);
    store64_le(sizes + 8, ctx->message_size);
    crypto_poly1305_update(&ctx->poly, zero, ALIGN(ctx->message_size, 16));
    crypto_poly1305_update(&ctx->poly, sizes, 16);
    crypto_poly1305_final (&ctx->poly, mac);
    WIPE_CTX(ctx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x671a
movq 0xd8(%rbx), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq 0xe0(%rbx), %rdx
movq %rdx, 0x8(%r15)
leaq 0x88(%rbx), %r12
negl %edx
andl $0xf, %edx
leaq 0x2e50(%rip), %rsi      # 0x9600
movq %r12, %rdi
callq 0x1c81
pushq $0x10
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1c81
movq %r12, %rdi
movq %r14, %rsi
callq 0x1f0f
movl $0xf0, %esi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1734
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_unlock_final
int crypto_unlock_final(crypto_lock_ctx *ctx, const u8 mac[16])
{
    u8 real_mac[16];
    crypto_lock_final(ctx, real_mac);
    int mismatch = crypto_verify16(real_mac, mac);
    WIPE_BUFFER(real_mac);
    return mismatch;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
callq 0x676f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x167c
movl %eax, %ebx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x1734
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: crypto_lock_aead
void crypto_lock_aead(u8        mac[16],
                      u8       *cipher_text,
                      const u8  key[32],
                      const u8  nonce[24],
                      const u8 *ad        , size_t ad_size,
                      const u8 *plain_text, size_t text_size)
{
    crypto_lock_ctx ctx;
    crypto_lock_init   (&ctx, key, nonce);
    crypto_lock_auth_ad(&ctx, ad, ad_size);
    crypto_lock_update (&ctx, cipher_text, plain_text, text_size);
    crypto_lock_final  (&ctx, mac);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x138(%rsp), %rbp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x6660
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x66c1
movq %r13, %rdi
movq %r15, %rsi
movq 0x130(%rsp), %rdx
movq %rbp, %rcx
callq 0x6749
movq %r13, %rdi
movq %r12, %rsi
callq 0x676f
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq