LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_add
static void ge_add(ge *s, const ge *p, const ge_cached *q)
{
    fe a, b; // not used to process secrets, no need to wipe
    fe_add(a   , p->Y, p->X );
    fe_sub(b   , p->Y, p->X );
    fe_mul(a   , a   , q->Yp);
    fe_mul(b   , b   , q->Ym);
    fe_add(s->Y, a   , b    );
    fe_sub(s->X, a   , b    );

    fe_add(s->Z, p->Z, p->Z );
    fe_mul(s->Z, s->Z, q->Z );
    fe_mul(s->T, p->T, q->T2);
    fe_add(a   , s->Z, s->T );
    fe_sub(b   , s->Z, s->T );

    fe_mul(s->T, s->X, s->Y);
    fe_mul(s->X, s->X, b   );
    fe_mul(s->Y, s->Y, a   );
    fe_mul(s->Z, a   , b   );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0x9130
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0x90e0
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9180
leaq -0x70(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
callq 0x9180
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x9130
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x90e0
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movq -0x10(%rbp), %rdx
addq $0x50, %rdx
callq 0x9130
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x18(%rbp), %rdx
addq $0x50, %rdx
callq 0x9180
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
movq -0x18(%rbp), %rdx
addq $0x78, %rdx
callq 0x9180
leaq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
callq 0x9130
leaq -0x70(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x50, %rsi
movq -0x8(%rbp), %rdx
addq $0x78, %rdx
callq 0x90e0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x28, %rdx
callq 0x9180
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x9180
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq -0x40(%rbp), %rdx
callq 0x9180
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x9180
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_sub
static void ge_sub(ge *s, const ge *p, const ge_cached *q)
{
    ge_cached neg;
    fe_copy(neg.Ym, q->Yp);
    fe_copy(neg.Yp, q->Ym);
    fe_copy(neg.Z , q->Z );
    fe_neg (neg.T2, q->T2);
    ge_add(s, p, &neg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xb8(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rsi
callq 0x8fe0
leaq -0xb8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x8fe0
leaq -0xb8(%rbp), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rsi
addq $0x50, %rsi
callq 0x8fe0
leaq -0xb8(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
callq 0xfb90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x105e0
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/monocypher.c
// Function: ge_cache
static void ge_cache(ge_cached *c, const ge *p)
{
    static const fe D2 = { // - 2 * 121665 / 121666
        -21827239, -5839606, -30745221, 13898782, 229458,
        15978800, -12551817, -6495438, 29715968, 9444199
    };
    fe_add (c->Yp, p->Y, p->X);
    fe_sub (c->Ym, p->Y, p->X);
    fe_copy(c->Z , p->Z      );
    fe_mul (c->T2, p->T, D2  );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0x9130
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rdx
callq 0x90e0
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x8fe0
movq -0x8(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
leaq 0x2816(%rip), %rdx      # 0x13070
callq 0x9180
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512_init
void crypto_sha512_init(crypto_sha512_ctx *ctx)
{
    ctx->hash[0] = 0x6a09e667f3bcc908;
    ctx->hash[1] = 0xbb67ae8584caa73b;
    ctx->hash[2] = 0x3c6ef372fe94f82b;
    ctx->hash[3] = 0xa54ff53a5f1d36f1;
    ctx->hash[4] = 0x510e527fade682d1;
    ctx->hash[5] = 0x9b05688c2b3e6c1f;
    ctx->hash[6] = 0x1f83d9abfb41bd6b;
    ctx->hash[7] = 0x5be0cd19137e2179;
    ctx->input_size[0] = 0;
    ctx->input_size[1] = 0;
    ctx->input_idx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movabsq $0x6a09e667f3bcc908, %rcx # imm = 0x6A09E667F3BCC908
movq %rcx, 0x280(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x4498517a7b3558c5, %rcx # imm = 0xBB67AE8584CAA73B
movq %rcx, 0x288(%rax)
movq -0x8(%rbp), %rax
movabsq $0x3c6ef372fe94f82b, %rcx # imm = 0x3C6EF372FE94F82B
movq %rcx, 0x290(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x5ab00ac5a0e2c90f, %rcx # imm = 0xA54FF53A5F1D36F1
movq %rcx, 0x298(%rax)
movq -0x8(%rbp), %rax
movabsq $0x510e527fade682d1, %rcx # imm = 0x510E527FADE682D1
movq %rcx, 0x2a0(%rax)
movq -0x8(%rbp), %rax
movabsq $-0x64fa9773d4c193e1, %rcx # imm = 0x9B05688C2B3E6C1F
movq %rcx, 0x2a8(%rax)
movq -0x8(%rbp), %rax
movabsq $0x1f83d9abfb41bd6b, %rcx # imm = 0x1F83D9ABFB41BD6B
movq %rcx, 0x2b0(%rax)
movq -0x8(%rbp), %rax
movabsq $0x5be0cd19137e2179, %rcx # imm = 0x5BE0CD19137E2179
movq %rcx, 0x2b8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x340(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x348(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x350(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512_update
void crypto_sha512_update(crypto_sha512_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);
    sha512_update(ctx, message, align);
    message      += align;
    message_size -= align;

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

    // remaining bytes
    sha512_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 0x350(%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
andq $0x7f, %rax
cmpq -0x18(%rbp), %rax
ja 0x1099e
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
andq $0x7f, %rax
movq %rax, -0x38(%rbp)
jmp 0x109a6
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 0x10aa0
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 0x10a7c
movq $0x0, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jae 0x10a3b
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x10b10
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rdx, 0x2c0(%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x109ff
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rcx
addq $0x80, %rcx
movq %rcx, 0x350(%rax)
movq -0x8(%rbp), %rdi
callq 0x10b90
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x109e2
movq -0x18(%rbp), %rax
andq $0x7f, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10aa0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: sha512_update
static void sha512_update(crypto_sha512_ctx *ctx,
                          const u8 *message, size_t message_size)
{
    FOR (i, 0, message_size) {
        sha512_set_input(ctx, message[i]);
        ctx->input_idx++;
        sha512_end_block(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 0x10b08
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x10d40
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x350(%rax)
movq -0x8(%rbp), %rdi
callq 0x10b90
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10abc
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: sha512_end_block
static void sha512_end_block(crypto_sha512_ctx *ctx)
{
    if (ctx->input_idx == 128) {
        sha512_incr(ctx->input_size, 1024); // size is in bits
        sha512_compress(ctx);
        ctx->input_idx = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x80, 0x350(%rax)
jne 0x10bda
movq -0x8(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
movl $0x400, %esi            # imm = 0x400
callq 0x10d00
movq -0x8(%rbp), %rdi
callq 0x10df0
movq -0x8(%rbp), %rax
movq $0x0, 0x350(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: crypto_sha512_final
void crypto_sha512_final(crypto_sha512_ctx *ctx, u8 hash[64])
{
    sha512_incr(ctx->input_size, ctx->input_idx * 8); // size is in bits
    sha512_set_input(ctx, 128);                       // padding

    // compress penultimate block (if any)
    if (ctx->input_idx > 111) {
        sha512_compress(ctx);
        FOR(i, 0, 14) {
            ctx->input[i] = 0;
        }
    }
    // compress last block
    ctx->input[14] = ctx->input_size[0];
    ctx->input[15] = ctx->input_size[1];
    sha512_compress(ctx);

    // copy hash to output (big endian)
    FOR (i, 0, 8) {
        store64_be(hash + i*8, ctx->hash[i]);
    }

    WIPE_CTX(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x340, %rdi            # imm = 0x340
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rsi
shlq $0x3, %rsi
callq 0x10d00
movq -0x8(%rbp), %rdi
movl $0x80, %esi
callq 0x10d40
movq -0x8(%rbp), %rax
cmpq $0x6f, 0x350(%rax)
jbe 0x10c67
movq -0x8(%rbp), %rdi
callq 0x10df0
movq $0x0, -0x18(%rbp)
cmpq $0xe, -0x18(%rbp)
jae 0x10c65
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x2c0(%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10c3c
jmp 0x10c67
movq -0x8(%rbp), %rax
movq 0x340(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x330(%rax)
movq -0x8(%rbp), %rax
movq 0x348(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x338(%rax)
movq -0x8(%rbp), %rdi
callq 0x10df0
movq $0x0, -0x20(%rbp)
cmpq $0x8, -0x20(%rbp)
jae 0x10cdd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x280(%rax,%rcx,8), %rsi
callq 0x110e0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x10ca4
movq -0x8(%rbp), %rdi
movl $0x358, %esi            # imm = 0x358
callq 0x111b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/sha512.c
// Function: sha512_set_input
static void sha512_set_input(crypto_sha512_ctx *ctx, u8 input)
{
    if (ctx->input_idx == 0) {
        FOR (i, 0, 16) {
            ctx->input[i] = 0;
        }
    }
    size_t word = ctx->input_idx / 8;
    size_t byte = ctx->input_idx % 8;
    ctx->input[word] |= (u64)input << (8 * (7 - byte));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x350(%rax)
jne 0x10d8f
movq $0x0, -0x18(%rbp)
cmpq $0x10, -0x18(%rbp)
jae 0x10d8d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x2c0(%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x10d64
jmp 0x10d8f
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rax
shrq $0x3, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x350(%rax), %rax
andq $0x7, %rax
movq %rax, -0x28(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, %edx
movl $0x7, %ecx
subq -0x28(%rbp), %rcx
shlq $0x3, %rcx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
orq 0x2c0(%rax,%rcx,8), %rdx
movq %rdx, 0x2c0(%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: getopt_init
void getopt_init(getopt_ctx *ctx, int argc, char *argv[])
{
    ctx->argc     = argc - 1; // remove program name
    ctx->argv     = argv + 1; // remove program name
    ctx->argv_idx = 0;
    ctx->char_idx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: getopt_next
int getopt_next(getopt_ctx *ctx)
{
    if (ctx->char_idx == 0) {
        int    idx  = ctx->argv_idx;
        char **argv = ctx->argv;
        // Search argv for the next option
        while (idx < ctx->argc &&
               (argv[idx][0] != '-' || is_dash(ctx, idx))) {
            idx++;
        }
        // No more arguments
        if (idx == ctx->argc) {
            return -1;
        }
        // End of options marker found.  No more options, Get rid of it.
        if (is_double_dash(ctx, idx)) {
            forget_argument(ctx, idx);
            return -1;
        }
        // Remember where the argument is stored
        ctx->argv_idx = idx;
    }
    // Point to the current option
    ctx->char_idx++;

    // Option has been found
    char* option_string  = ctx->argv[ctx->argv_idx] + ctx->char_idx;
    char  current_option = option_string[0];
    int   is_last        = option_string[1] == 0;
    if (is_last) {
        forget_argument(ctx, ctx->argv_idx);
    }
    return current_option;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1155f
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x31(%rbp)
jge 0x11504
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x2d, %ecx
movb %al, -0x32(%rbp)
jne 0x114fe
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x115e0
cmpl $0x0, %eax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1150d
jmp 0x11518
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x114c0
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1152f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x115cb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x11630
cmpl $0x0, %eax
je 0x11555
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x116a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x115cb
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x115c4
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x116a0
movsbl -0x29(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: forget_argument
static void forget_argument(getopt_ctx *ctx, int idx)
{
    char *tmp = ctx->argv[idx];
    while (idx > 0) {
        ctx->argv[idx] = ctx->argv[idx-1];
        idx--;
    }
    ctx->argv[0]  = tmp;
    ctx->char_idx = 0;  // point to the begining of the next argument
    ctx->argv++;
    ctx->argc--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x116f5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x116bf
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/getopt.c
// Function: getopt_parameter
char* getopt_parameter(getopt_ctx *ctx)
{
    int idx = ctx->argv_idx;
    if (idx >= ctx->argc || is_double_dash(ctx, idx)) {
        return 0; // missing option parameter
    }
    int   char_idx = ctx->char_idx == 0 ? 0 : ctx->char_idx + 1;
    char *argument = ctx->argv[idx] + char_idx;
    forget_argument(ctx, idx);
    return argument;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x11762
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x11630
cmpl $0x0, %eax
je 0x1176c
movq $0x0, -0x8(%rbp)
jmp 0x117bf
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1177d
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x1178a
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x116a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: alloc
void* alloc(size_t size)
{
    if (size == 0) { return 0; } // for portability
    void *buf = malloc(size);
    if (buf == NULL) {
        fprintf(stderr, "Failed to allocate 0x%zx bytes\n", size);
        panic("Out of memory.");
    }
    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x117ed
movq $0x0, -0x8(%rbp)
jmp 0x11831
movq -0x10(%rbp), %rdi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11829
movq 0x57f0(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1b1a(%rip), %rsi      # 0x13330
movb $0x0, %al
callq 0x1070
leaq 0x1b2c(%rip), %rdi      # 0x13350
callq 0x11840
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: random_bytes
void random_bytes(uint8_t *buffer, size_t buffer_size)
{
    if (buffer_size > 256 ) {
        panic("Requested too many random bytes (<= 256)");
    }
    if (syscall(SYS_getrandom, buffer, buffer_size, 0) != (int)buffer_size) {
        fprintf(stderr, "Failed to provide %zu random bytes", buffer_size);
        panic("");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jbe 0x11886
leaq 0x1ade(%rip), %rdi      # 0x1335f
callq 0x11840
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x13e, %edi            # imm = 0x13E
xorl %ecx, %ecx
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
je 0x118d0
movq 0x5749(%rip), %rax      # 0x16ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1acb(%rip), %rsi      # 0x13388
movb $0x0, %al
callq 0x1070
leaq 0x1ae9(%rip), %rdi      # 0x133b4
callq 0x11840
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: int_of_string
int int_of_string(const char *s)
{
    int i = 0;
    if ( s == 0   ) return -1; // NULL  string
    if (*s == '\0') return -2; // empty string
    while (*s != 0) {
        if (!is_between(*s, '0', '9')            ) return -2; // not a number
        if (i > (INT_MAX - int_of_digit(*s)) / 10) return -3; // too big for int
        i = (10 * i) + int_of_digit(*s);
        s++;
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x119a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11a5d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x119be
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x11a5d
jmp 0x119c0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11a57
movq -0x10(%rbp), %rax
movl $0x30, %esi
movl $0x39, %edx
movsbl (%rax), %edi
callq 0x11a70
cmpl $0x0, %eax
jne 0x119f4
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x11a5d
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x11ab0
movl %eax, %ecx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subl %ecx, %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jle 0x11a29
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x11a5d
imull $0xa, -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x11ab0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x119c0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: read_buffer
int read_buffer(uint8_t *out, size_t max_size, const char *hex)
{
    size_t hex_size = string_length(hex);
    size_t buf_size = hex_size / 2;
    if (hex ==  0          ) return -1;
    if (hex_size > max_size) return -2;
    if (hex_size % 2 !=   0) return -3;
    for (size_t i = 0; i < hex_size; i += 2) {
        int msb = int_of_hex(hex[i  ]);
        int lsb = int_of_hex(hex[i+1]);
        if (msb == -1 || lsb == -1) return -4;
        out[i/2] = lsb + (msb << 4);
    }
    return buf_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11c50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11b8f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11c3f
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x11ba5
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x11c3f
movq -0x28(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x11bbf
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x11c3f
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x11c38
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x11cb0
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %edi
callq 0x11cb0
movl %eax, -0x40(%rbp)
cmpl $-0x1, -0x3c(%rbp)
je 0x11c06
cmpl $-0x1, -0x40(%rbp)
jne 0x11c0f
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x11c3f
movl -0x40(%rbp), %eax
movl -0x3c(%rbp), %ecx
shll $0x4, %ecx
addl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
shrq %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
jmp 0x11bc7
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: string_length
static size_t string_length(const char *s)
{
    if (s == 0) { return -1u; }
    size_t i = 0;
    while(*s != '\0') { i++; s++; }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11c6a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x8(%rbp)
jmp 0x11ca0
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x11c98
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11c72
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: int_of_hex
static int int_of_hex(char c)
{
    return is_between(c, '0', '9') ? c - '0'
        :  is_between(c, 'a', 'f') ? c - 'a'
        :  is_between(c, 'A', 'F') ? c - 'A'
        :  -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x30, %esi
movl $0x39, %edx
movsbl -0x1(%rbp), %edi
callq 0x11a70
cmpl $0x0, %eax
je 0x11ce2
movsbl -0x1(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rbp)
jmp 0x11d40
movl $0x61, %esi
movl $0x66, %edx
movsbl -0x1(%rbp), %edi
callq 0x11a70
cmpl $0x0, %eax
je 0x11d06
movsbl -0x1(%rbp), %eax
subl $0x61, %eax
movl %eax, -0xc(%rbp)
jmp 0x11d3a
movl $0x41, %esi
movl $0x46, %edx
movsbl -0x1(%rbp), %edi
callq 0x11a70
cmpl $0x0, %eax
je 0x11d2a
movsbl -0x1(%rbp), %eax
subl $0x41, %eax
movl %eax, -0x10(%rbp)
jmp 0x11d34
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x10(%rbp)
jmp 0x11d34
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: read_vector
int read_vector(vector *v, const char *hex)
{
    v->size   = string_length(hex) / 2;
    v->buffer = alloc(v->size);
    int error = read_buffer(v->buffer, INT_MAX, hex);
    if (error < 1) {
        free_vector(v);
        return error;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11c50
movq %rax, %rcx
shrq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x117d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
callq 0x11b50
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x11ddd
movq -0x10(%rbp), %rdi
callq 0x11df0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11de4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LoupVaillant[P]Monocypher-Utils/src/utils.c
// Function: free_vector
void free_vector(vector *v)
{
    if (v->buffer != 0) {
        free(v->buffer);
        v->buffer = 0;
    }
    v->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11e1d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/impact-eintr[P]st/st.c
// Function: base64dec
char *
base64dec(const char *src)
{
	size_t in_len = strlen(src);
	char *result, *dst;

	if (in_len % 4)
		in_len += 4 - (in_len % 4);
	result = dst = xmalloc(in_len / 4 * 3 + 1);
	while (*src) {
		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
		int d = base64_digits[(unsigned char) base64dec_getc(&src)];

		/* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
		if (a == -1 || b == -1)
			break;

		*dst++ = (a << 2) | ((b & 0x30) >> 4);
		if (c == -1)
			break;
		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
		if (d == -1)
			break;
		*dst++ = ((c & 0x03) << 6) | d;
	}
	*dst = '\0';
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xa79f
movq -0x10(%rbp), %rcx
andq $0x3, %rcx
movl $0x4, %eax
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x2, %rax
imulq $0x3, %rax, %rdi
addq $0x1, %rdi
callq 0x5a40
movq %rax, -0x20(%rbp)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa8c6
leaq -0x8(%rbp), %rdi
callq 0xaa40
movzbl %al, %eax
movl %eax, %ecx
leaq 0x7f72(%rip), %rax      # 0x12750
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xaa40
movzbl %al, %eax
movl %eax, %ecx
leaq 0x7f56(%rip), %rax      # 0x12750
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xaa40
movzbl %al, %eax
movl %eax, %ecx
leaq 0x7f3a(%rip), %rax      # 0x12750
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xaa40
movzbl %al, %eax
movl %eax, %ecx
leaq 0x7f1e(%rip), %rax      # 0x12750
movsbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0xa845
cmpl $-0x1, -0x28(%rbp)
jne 0xa847
jmp 0xa8c6
movl -0x24(%rbp), %eax
shll $0x2, %eax
movl -0x28(%rbp), %ecx
andl $0x30, %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $-0x1, -0x2c(%rbp)
jne 0xa873
jmp 0xa8c6
movl -0x28(%rbp), %eax
andl $0xf, %eax
shll $0x4, %eax
movl -0x2c(%rbp), %ecx
andl $0x3c, %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
cmpl $-0x1, -0x30(%rbp)
jne 0xa8a2
jmp 0xa8c6
movl -0x2c(%rbp), %eax
andl $0x3, %eax
shll $0x6, %eax
orl -0x30(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xa7bc
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/impact-eintr[P]st/x.c
// Function: xseticontitle
void
xseticontitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
			&prop);
	XSetWMIconName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmiconname);
	XFree(prop.value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc65d
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xc668
movq 0xfd4c(%rip), %rax      # 0x1c3b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0xfc01(%rip), %rdi      # 0x1c278
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x5420
movq 0xfbe3(%rip), %rdi      # 0x1c278
movq 0xfbec(%rip), %rsi      # 0x1c288
leaq -0x28(%rbp), %rdx
callq 0x5320
movq 0xfbcc(%rip), %rdi      # 0x1c278
movq 0xfbd5(%rip), %rsi      # 0x1c288
movq 0xfbfe(%rip), %rcx      # 0x1c2b8
leaq -0x28(%rbp), %rdx
callq 0x5440
movq -0x28(%rbp), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/impact-eintr[P]st/x.c
// Function: xsettitle
void
xsettitle(char *p)
{
	XTextProperty prop;
	DEFAULT(p, opt_title);

	Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle,
			&prop);
	XSetWMName(xw.dpy, xw.win, &prop);
	XSetTextProperty(xw.dpy, xw.win, &prop, xw.netwmname);
	XFree(prop.value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc6fd
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0xc708
movq 0xfcac(%rip), %rax      # 0x1c3b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0xfb61(%rip), %rdi      # 0x1c278
leaq -0x8(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
leaq -0x28(%rbp), %r8
callq 0x5420
movq 0xfb43(%rip), %rdi      # 0x1c278
movq 0xfb4c(%rip), %rsi      # 0x1c288
leaq -0x28(%rbp), %rdx
callq 0x53e0
movq 0xfb2c(%rip), %rdi      # 0x1c278
movq 0xfb35(%rip), %rsi      # 0x1c288
movq 0xfb56(%rip), %rcx      # 0x1c2b0
leaq -0x28(%rbp), %rdx
callq 0x5440
movq -0x28(%rbp), %rdi
callq 0x5090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/impact-eintr[P]st/x.c
// Function: cresize
void
cresize(int width, int height)
{
	int col, row;

	if (width != 0)
		win.w = width;
	if (height != 0)
		win.h = height;

	col = (win.w - 2 * borderpx) / win.cw;
	row = (win.h - 2 * borderpx) / win.ch;
	col = MAX(1, col);
	row = MAX(1, row);

	win.hborderpx = (win.w - col * win.cw) / 2;
	win.vborderpx = (win.h - row * win.ch) / 2;

	tresize(col, row);
	xresize(col, row);
	ttyresize(win.tw, win.th);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0xfb4d
movl -0x4(%rbp), %eax
movl %eax, 0xc843(%rip)      # 0x1c390
cmpl $0x0, -0x8(%rbp)
je 0xfb5c
movl -0x8(%rbp), %eax
movl %eax, 0xc838(%rip)      # 0x1c394
movl 0xc82e(%rip), %eax      # 0x1c390
movl 0x83a4(%rip), %ecx      # 0x17f0c
shll %ecx
subl %ecx, %eax
cltd
idivl 0xc831(%rip)            # 0x1c3a4
movl %eax, -0xc(%rbp)
movl 0xc818(%rip), %eax      # 0x1c394
movl 0x838a(%rip), %ecx      # 0x17f0c
shll %ecx
subl %ecx, %eax
cltd
idivl 0xc813(%rip)            # 0x1c3a0
movl %eax, -0x10(%rbp)
movl $0x1, %eax
cmpl -0xc(%rbp), %eax
jge 0xfba2
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xfbac
movl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfbac
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x1, %eax
cmpl -0x10(%rbp), %eax
jge 0xfbc4
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xfbce
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xfbce
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl 0xc7b6(%rip), %eax      # 0x1c390
movl -0xc(%rbp), %ecx
imull 0xc7c0(%rip), %ecx      # 0x1c3a4
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0xc7a4(%rip)      # 0x1c398
movl 0xc79a(%rip), %eax      # 0x1c394
movl -0x10(%rbp), %ecx
imull 0xc79c(%rip), %ecx      # 0x1c3a0
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0xc788(%rip)      # 0x1c39c
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x7600
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0xfc50
movl 0xc758(%rip), %edi      # 0x1c388
movl 0xc756(%rip), %esi      # 0x1c38c
callq 0x73d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/impact-eintr[P]st/x.c
// Function: bpress
void
bpress(XEvent *e)
{
	struct timespec now;
	int snap;

	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 0))
		return;

	if (e->xbutton.button == Button1) {
		/*
		 * If the user clicks below predefined timeouts specific
		 * snapping behaviour is exposed.
		 */
		clock_gettime(CLOCK_MONOTONIC, &now);
		if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) {
			snap = SNAP_LINE;
		} else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) {
			snap = SNAP_WORD;
		} else {
			snap = 0;
		}
		xsel.tclick2 = xsel.tclick1;
		xsel.tclick1 = now;

		selstart(evcol(e), evrow(e), snap);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl 0xc4d6(%rip), %eax      # 0x1c3a8
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0xfefc
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x9db7(%rip), %eax      # 0x19ca0
cmpl $0x0, %eax
jne 0xfefc
movq -0x8(%rbp), %rdi
callq 0x10cf0
jmp 0x10038
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10f80
cmpl $0x0, %eax
je 0xff11
jmp 0x10038
movq -0x8(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0x10038
movl $0x1, %edi
leaq -0x18(%rbp), %rsi
callq 0x5130
movq 0xc4f4(%rip), %rdx      # 0x1c428
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rdx, %rcx
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm1
movq 0xc4de(%rip), %rcx      # 0x1c430
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x2ece(%rip), %xmm2     # 0x12e30
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
movl 0x9d34(%rip), %eax      # 0x19ca4
cvtsi2sd %rax, %xmm0
ucomisd %xmm1, %xmm0
jb 0xff84
movl $0x2, -0x1c(%rbp)
jmp 0xffe4
movq 0xc48d(%rip), %rdx      # 0x1c418
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rdx, %rcx
imulq $0x3e8, %rcx, %rcx      # imm = 0x3E8
cvtsi2sd %rcx, %xmm1
movq 0xc477(%rip), %rcx      # 0x1c420
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x2e77(%rip), %xmm2     # 0x12e30
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
movl 0x9ce1(%rip), %eax      # 0x19ca8
cvtsi2sd %rax, %xmm0
ucomisd %xmm1, %xmm0
jb 0xffdb
movl $0x1, -0x1c(%rbp)
jmp 0xffe2
movl $0x0, -0x1c(%rbp)
jmp 0xffe4
movq 0xc42d(%rip), %rax      # 0x1c418
movq %rax, 0xc436(%rip)      # 0x1c428
movq 0xc427(%rip), %rax      # 0x1c420
movq %rax, 0xc430(%rip)      # 0x1c430
movq -0x18(%rbp), %rax
movq %rax, 0xc40d(%rip)      # 0x1c418
movq -0x10(%rbp), %rax
movq %rax, 0xc40a(%rip)      # 0x1c420
movq -0x8(%rbp), %rdi
callq 0x11060
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x110d0
movl -0x20(%rbp), %edi
movl %eax, %esi
movl -0x1c(%rbp), %edx
callq 0x5d80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/impact-eintr[P]st/x.c
// Function: brelease
void
brelease(XEvent *e)
{
	if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forcemousemod)) {
		mousereport(e);
		return;
	}

	if (mouseaction(e, 1))
		return;
	if (e->xbutton.button == Button1)
		mousesel(e, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xc356(%rip), %eax      # 0x1c3a8
andl $0xc018, %eax           # imm = 0xC018
cmpl $0x0, %eax
je 0x10079
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
andl 0x9c37(%rip), %eax      # 0x19ca0
cmpl $0x0, %eax
jne 0x10079
movq -0x8(%rbp), %rdi
callq 0x10cf0
jmp 0x100a6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x10f80
cmpl $0x0, %eax
je 0x1008e
jmp 0x100a6
movq -0x8(%rbp), %rax
cmpl $0x1, 0x54(%rax)
jne 0x100a6
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x11200
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jani-nykanen[P]mushrooms/./tools/src/png2spr.c
// Function: main
i32 main(i32 argc, str* argv) {

    i32 frameWidth;
    i32 frameHeight;

    if(argc < 5) {

        fprintf(stderr, "Must pass at least 4 arguments.\nHelp: png2spr input output framewidth frameheight (-mask)\n");
        return 1;
    }

    frameWidth = (i32) strtol(argv[3], NULL, 10);
    frameHeight = (i32) strtol(argv[4], NULL, 10);

    return convert_bitmap(argv[1], argv[2], includes_str("-mask", argv, argc, 1), 
        frameWidth, frameHeight);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x2c5d
movq 0x1c3b5(%rip), %rax     # 0x1eff8
movq (%rax), %rdi
leaq 0x17a7a(%rip), %rsi     # 0x1a6c7
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x4(%rbp)
jmp 0x2cdc
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1100
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1100
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movl -0x8(%rbp), %edx
leaq 0x17a6d(%rip), %rdi     # 0x1a722
movl $0x1, %ecx
callq 0x3060
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movzbl %al, %edx
andl $0x1, %edx
callq 0x2cf0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jani-nykanen[P]mushrooms/./tools/src/png2spr.c
// Function: includes_str
static bool includes_str(const str word, str* argv, u32 len, u32 start) {
    
	u32 i;
	
	for (i = start; i < len; ++ i) {
		
		if (strcmp(word, argv[i]) == 0)
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x30b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x30a3
movb $0x1, -0x1(%rbp)
jmp 0x30b4
jmp 0x30a5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x307c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jani-nykanen[P]mushrooms/./tools/src/stb_image.h
// Function: stbi__bmp_info
static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp)
{
   void *p;
   stbi__bmp_data info;

   info.all_a = 255;
   p = stbi__bmp_parse_header(s, &info);
   stbi__rewind( s );
   if (p == NULL)
      return 0;
   if (x) *x = s->img_x;
   if (y) *y = s->img_y;
   if (comp) {
      if (info.bpp == 24 && info.ma == 0xff000000)
         *comp = 3;
      else
         *comp = info.ma ? 4 : 3;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0xff, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x15480
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a20
cmpq $0x0, -0x30(%rbp)
jne 0x19149
movl $0x0, -0x4(%rbp)
jmp 0x191b4
cmpq $0x0, -0x18(%rbp)
je 0x1915c
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x19170
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x191ad
cmpl $0x18, -0x50(%rbp)
jne 0x19192
cmpl $0xff000000, -0x38(%rbp) # imm = 0xFF000000
jne 0x19192
movq -0x28(%rbp), %rax
movl $0x3, (%rax)
jmp 0x191ab
movl -0x38(%rbp), %edx
movl $0x3, %ecx
movl $0x4, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
jmp 0x191ad
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jani-nykanen[P]mushrooms/./tools/src/png2spr.c
// Function: find_color
static i32 find_color(u8* data, u32 loc) {

    i32 i, j;
    for (i = 0; i < 4; ++ i) {

        for (j = 0; j < 3; ++ j) {

            if (data[loc + j] != COLORS[i][j])
                break;

            if (j == 2)
                return i;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x19d2d
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x19d20
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movslq -0x18(%rbp), %rdx
leaq 0x5484(%rip), %rcx      # 0x1f174
imulq $0x3, %rdx, %rdx
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x19d05
jmp 0x19d20
cmpl $0x2, -0x1c(%rbp)
jne 0x19d13
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19d34
jmp 0x19d15
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19ccf
jmp 0x19d22
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19cc2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jani-nykanen[P]mushrooms/./tools/src/png2spr.c
// Function: write_array
static void write_array(FILE* f, u8* arr, u32 len) {
    
    u32 i;
    u32 count = 3;
    u8 bout = 0;

    for (i = 0; i < len; ++ i) {

        bout = bout | (arr[i] << (count*2));

        if (count -- == 0) {

            fwrite(&bout, 1, 1, f);
            bout = 0;
            count = 3;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x3, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x19f77
movzbl -0x1d(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %edx
movzbl (%rcx,%rdx), %edx
movl -0x1c(%rbp), %ecx
shll %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
jne 0x19f6a
movq -0x8(%rbp), %rcx
leaq -0x1d(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1160
movb $0x0, -0x1d(%rbp)
movl $0x3, -0x1c(%rbp)
jmp 0x19f6c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19f15
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/evilwombat[P]gopro-fw-tools/h3plus-section-patch.c
// Function: print_usage
static void print_usage(const char *name)
{
	printf("Usage: %s unpatched_firmware.bin section_filename section_number output_firmware.bin\n\n", name);
	printf("unpatched_firmware.bin - original, unpatched HD3.11-firmware.bin file\n");
	printf("section_filename       - filename of replacement section being packed into the firmware\n");
	printf("section_number         - number of section to replace\n");
	printf("output_firmware.bin    - filename for where to write the modified HD3.11-firmware.bin file\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1d1b(%rip), %rdi      # 0x3dc2
movb $0x0, %al
callq 0x1060
leaq 0x1d64(%rip), %rdi      # 0x3e19
movb $0x0, %al
callq 0x1060
leaq 0x1d9d(%rip), %rdi      # 0x3e60
movb $0x0, %al
callq 0x1060
leaq 0x1de8(%rip), %rdi      # 0x3eb9
movb $0x0, %al
callq 0x1060
leaq 0x1e11(%rip), %rdi      # 0x3ef0
movb $0x0, %al
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)