LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/main.c
// Function: skein256
void skein256(char* input, char* output) {
    
    uint32_t result[8];
    sph_skein256_context ctx_skein;
    
    sph_skein256_init(&ctx_skein);
    sph_skein256(&ctx_skein, input, 32); 
    sph_skein256_close(&ctx_skein, result);
    
    memcpy(output, result, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x5aa80
movq -0x8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x20, %edx
callq 0x5aab0
leaq -0x30(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x5aae0
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/main.c
// Function: bmw256
void bmw256(char* input, char* output) {
    
    uint32_t result[8];
    sph_bmw256_context ctx_bmw;
    
    sph_bmw256_init(&ctx_bmw);
    sph_bmw256(&ctx_bmw, input, 32);
    sph_bmw256_close(&ctx_bmw, result);
    
    memcpy(output, result, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x28180
movq -0x8(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
movl $0x20, %edx
callq 0x281b0
leaq -0x30(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x281e0
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/main.c
// Function: main
int main(int argc, char *argv[]) {
    
    char* algorithm;
    char* input;
    char input_hex[32];
    char output[32];
    bool all = false;
    
    if (argc <= 1) {
        printf("Arguments is missing\n");
        exit(1);
    }

    all = argc == 2;

    if (all) {

        input = argv[1];

        for (size_t count = 0; count < sizeof(input_hex) / sizeof(*input_hex); count++) {
            sscanf(input, "%2hhx", &input_hex[count]);
            input += 2;
        }

        for(int i = 0; i < sizeof(algorithms) / sizeof(*algorithms); i++) {
            print_hash(algorithms[i], input_hex, output);
        }

    } else {

        algorithm = argv[1];
        input = argv[2];

        for (size_t count = 0; count < sizeof(input_hex) / sizeof(*input_hex); count++) {
            sscanf(input, "%2hhx", &input_hex[count]);
            input += 2;
        }

        print_hash(algorithm, input_hex, output);
    }
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x61(%rbp)
cmpl $0x1, -0x8(%rbp)
jg 0x164b
leaq 0x59a22(%rip), %rdi     # 0x5b05c
movb $0x0, %al
callq 0x1050
movl $0x1, %edi
callq 0x10b0
cmpl $0x2, -0x8(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x61(%rbp)
testb $0x1, -0x61(%rbp)
je 0x16ea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x70(%rbp)
cmpq $0x20, -0x70(%rbp)
jae 0x16b0
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rdx
addq -0x70(%rbp), %rdx
leaq 0x599e3(%rip), %rsi     # 0x5b072
movb $0x0, %al
callq 0x10a0
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0x1675
movl $0x0, -0x74(%rbp)
movslq -0x74(%rbp), %rax
cmpq $0x6, %rax
jae 0x16e8
movslq -0x74(%rbp), %rcx
leaq 0x619a4(%rip), %rax     # 0x63070
movq (%rax,%rcx,8), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x13f0
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x16b7
jmp 0x1756
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x80(%rbp)
cmpq $0x20, -0x80(%rbp)
jae 0x1745
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rdx
addq -0x80(%rbp), %rdx
leaq 0x5994e(%rip), %rsi     # 0x5b072
movb $0x0, %al
callq 0x10a0
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x170a
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x13f0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Lyra2RE.c
// Function: lyra2re_hash
void lyra2re_hash(const char* input, char* output)
{
    sph_blake256_context     ctx_blake;
    sph_groestl256_context   ctx_groestl;
    sph_keccak256_context    ctx_keccak;
    sph_skein256_context     ctx_skein;

    uint32_t hashA[8], hashB[8];

    sph_blake256_init(&ctx_blake);
    sph_blake256 (&ctx_blake, input, 80);
    sph_blake256_close (&ctx_blake, hashA);	
	
    sph_keccak256_init(&ctx_keccak);
    sph_keccak256 (&ctx_keccak,hashA, 32); 
    sph_keccak256_close(&ctx_keccak, hashB);
	
	LYRA2_old(hashA, 32, hashB, 32, hashB, 32, 1, 8, 8);
	
	sph_skein256_init(&ctx_skein);
    sph_skein256 (&ctx_skein, hashA, 32); 
    sph_skein256_close(&ctx_skein, hashB); 

    sph_groestl256_init(&ctx_groestl);
    sph_groestl256 (&ctx_groestl, hashB, 32); 
    sph_groestl256_close(&ctx_groestl, hashA); 

	memcpy(output, hashA, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp            # imm = 0x380
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c430
movq -0x8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x50, %edx
callq 0x1c460
leaq -0x340(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1c490
leaq -0x288(%rbp), %rdi
callq 0x4da30
leaq -0x340(%rbp), %rsi
leaq -0x288(%rbp), %rdi
movl $0x20, %edx
callq 0x4da50
leaq -0x360(%rbp), %rsi
leaq -0x288(%rbp), %rdi
callq 0x4da80
leaq -0x340(%rbp), %rdi
leaq -0x360(%rbp), %rdx
leaq -0x360(%rbp), %r8
movl $0x20, %r9d
movq %r9, %rsi
movq %r9, %rcx
movq $0x1, (%rsp)
movq $0x8, 0x8(%rsp)
movq $0x8, 0x10(%rsp)
callq 0x2060
leaq -0x318(%rbp), %rdi
callq 0x5aa80
leaq -0x340(%rbp), %rsi
leaq -0x318(%rbp), %rdi
movl $0x20, %edx
callq 0x5aab0
leaq -0x360(%rbp), %rsi
leaq -0x318(%rbp), %rdi
callq 0x5aae0
leaq -0x120(%rbp), %rdi
callq 0xd280
leaq -0x360(%rbp), %rsi
leaq -0x120(%rbp), %rdi
movl $0x20, %edx
callq 0xd2a0
leaq -0x340(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0xd2d0
movq -0x10(%rbp), %rax
movq -0x340(%rbp), %rcx
movq %rcx, (%rax)
movq -0x338(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x330(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x328(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x380, %rsp            # imm = 0x380
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Lyra2RE.c
// Function: lyra2re2_hash
void lyra2re2_hash(const char* input, char* output)
{
	sph_blake256_context ctx_blake;
	sph_cubehash256_context ctx_cubehash;
	sph_keccak256_context ctx_keccak;
	sph_skein256_context ctx_skein;
	sph_bmw256_context ctx_bmw;
	
	uint32_t hashA[8], hashB[8];
	
	sph_blake256_init(&ctx_blake);
    sph_blake256(&ctx_blake, input, 80);
    sph_blake256_close (&ctx_blake, hashA);	
	
    sph_keccak256_init(&ctx_keccak);
    sph_keccak256(&ctx_keccak, hashA, 32); 
    sph_keccak256_close(&ctx_keccak, hashB);
    
    sph_cubehash256_init(&ctx_cubehash);
    sph_cubehash256(&ctx_cubehash, hashB, 32);
    sph_cubehash256_close(&ctx_cubehash, hashA);
    
    LYRA2(hashB, 32, hashA, 32, hashA, 32, 1, 4, 4);
    
   	sph_skein256_init(&ctx_skein);
    sph_skein256(&ctx_skein, hashB, 32); 
    sph_skein256_close(&ctx_skein, hashA);
    
    sph_cubehash256_init(&ctx_cubehash);
    sph_cubehash256(&ctx_cubehash, hashA, 32);
    sph_cubehash256_close(&ctx_cubehash, hashB);
    
    sph_bmw256_init(&ctx_bmw);
    sph_bmw256(&ctx_bmw, hashB, 32);
    sph_bmw256_close(&ctx_bmw, hashA);
    
   	memcpy(output, hashA, 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c430
movq -0x8(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x50, %edx
callq 0x1c460
leaq -0x3e0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x1c490
leaq -0x2a0(%rbp), %rdi
callq 0x4da30
leaq -0x3e0(%rbp), %rsi
leaq -0x2a0(%rbp), %rdi
movl $0x20, %edx
callq 0x4da50
leaq -0x400(%rbp), %rsi
leaq -0x2a0(%rbp), %rdi
callq 0x4da80
leaq -0x138(%rbp), %rdi
callq 0x42e10
leaq -0x400(%rbp), %rsi
leaq -0x138(%rbp), %rdi
movl $0x20, %edx
callq 0x42e40
leaq -0x3e0(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x42e70
leaq -0x400(%rbp), %rdi
leaq -0x3e0(%rbp), %rdx
leaq -0x3e0(%rbp), %r8
movl $0x20, %r9d
movq %r9, %rsi
movq %r9, %rcx
movq $0x1, (%rsp)
movq $0x4, 0x8(%rsp)
movq $0x4, 0x10(%rsp)
callq 0x1ac0
leaq -0x330(%rbp), %rdi
callq 0x5aa80
leaq -0x400(%rbp), %rsi
leaq -0x330(%rbp), %rdi
movl $0x20, %edx
callq 0x5aab0
leaq -0x3e0(%rbp), %rsi
leaq -0x330(%rbp), %rdi
callq 0x5aae0
leaq -0x138(%rbp), %rdi
callq 0x42e10
leaq -0x3e0(%rbp), %rsi
leaq -0x138(%rbp), %rdi
movl $0x20, %edx
callq 0x42e40
leaq -0x400(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0x42e70
leaq -0x3c0(%rbp), %rdi
callq 0x28180
leaq -0x400(%rbp), %rsi
leaq -0x3c0(%rbp), %rdi
movl $0x20, %edx
callq 0x281b0
leaq -0x3e0(%rbp), %rsi
leaq -0x3c0(%rbp), %rdi
callq 0x281e0
movq -0x10(%rbp), %rax
movq -0x3e0(%rbp), %rcx
movq %rcx, (%rax)
movq -0x3d8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x3d0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x3c8(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Sponge.c
// Function: initState
inline void initState(uint64_t state[/*16*/]) {
    //First 512 bis are zeros
    memset(state, 0, 64);
    //Remainder BLOCK_LEN_BLAKE2_SAFE_BYTES are reserved to the IV
    state[8] = blake2b_IV[0];
    state[9] = blake2b_IV[1];
    state[10] = blake2b_IV[2];
    state[11] = blake2b_IV[3];
    state[12] = blake2b_IV[4];
    state[13] = blake2b_IV[5];
    state[14] = blake2b_IV[6];
    state[15] = blake2b_IV[7];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1060
movq 0x58a4d(%rip), %rcx     # 0x5b080
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x58a46(%rip), %rcx     # 0x5b088
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x58a3f(%rip), %rcx     # 0x5b090
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq 0x58a38(%rip), %rcx     # 0x5b098
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x58a31(%rip), %rcx     # 0x5b0a0
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq 0x58a2a(%rip), %rcx     # 0x5b0a8
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq 0x58a23(%rip), %rcx     # 0x5b0b0
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq 0x58a1c(%rip), %rcx     # 0x5b0b8
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Sponge.c
// Function: squeeze
inline void squeeze(uint64_t *state, byte *out, unsigned int len) {
    int fullBlocks = len / BLOCK_LEN_BYTES;
    byte *ptr = out;
    int i;
    //Squeezes full blocks
    for (i = 0; i < fullBlocks; i++) {
	memcpy(ptr, state, BLOCK_LEN_BYTES);
	blake2bLyra(state);
	ptr += BLOCK_LEN_BYTES;
    }

    //Squeezes remaining bytes
    memcpy(ptr, state, (len % BLOCK_LEN_BYTES));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x60, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x271b
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x60, %edx
callq 0x1080
movq -0x8(%rbp), %rdi
callq 0x2740
movq -0x20(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x26e1
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
movl $0x60, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl %eax, %edx
callq 0x1080
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Sponge.c
// Function: absorbBlock
inline void absorbBlock(uint64_t *state, const uint64_t *in) {
    //XORs the first BLOCK_LEN_INT64 words of "in" with the current state
    state[0] ^= in[0];
    state[1] ^= in[1];
    state[2] ^= in[2];
    state[3] ^= in[3];
    state[4] ^= in[4];
    state[5] ^= in[5];
    state[6] ^= in[6];
    state[7] ^= in[7];
    state[8] ^= in[8];
    state[9] ^= in[9];
    state[10] ^= in[10];
    state[11] ^= in[11];

    //Applies the transformation f to the sponge's state
    blake2bLyra(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x48(%rax), %rcx
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
callq 0x2740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Sponge.c
// Function: absorbBlockBlake2Safe
inline void absorbBlockBlake2Safe(uint64_t *state, const uint64_t *in) {
    //XORs the first BLOCK_LEN_BLAKE2_SAFE_INT64 words of "in" with the current state

	state[0] ^= in[0];
    state[1] ^= in[1];
    state[2] ^= in[2];
    state[3] ^= in[3];
    state[4] ^= in[4];
    state[5] ^= in[5];
    state[6] ^= in[6];
    state[7] ^= in[7];


    //Applies the transformation f to the sponge's state
    blake2bLyra(state);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
xorq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
xorq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x2740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Sponge.c
// Function: reducedSqueezeRow0
inline void reducedSqueezeRow0(uint64_t* state, uint64_t* rowOut, uint64_t nCols) {
    uint64_t* ptrWord = rowOut + (nCols-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to M[0][C-1]
    int i;
    //M[row][C-1-col] = H.reduced_squeeze()
    for (i = 0; i < nCols; i++) {
	ptrWord[0] = state[0];
	ptrWord[1] = state[1];
	ptrWord[2] = state[2];
	ptrWord[3] = state[3];
	ptrWord[4] = state[4];
	ptrWord[5] = state[5];
	ptrWord[6] = state[6];
	ptrWord[7] = state[7];
	ptrWord[8] = state[8];
	ptrWord[9] = state[9];
	ptrWord[10] = state[10];
	ptrWord[11] = state[11];

	//Goes to next block (column) that will receive the squeezed data
	ptrWord -= BLOCK_LEN_INT64;

	//Applies the reduced-round transformation f to the sponge's state
	reducedBlake2bLyra(state);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
imulq $0xc, %rcx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x85f5
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
addq $-0x60, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8600
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8506
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/Sponge.c
// Function: printArray
void printArray(unsigned char *array, unsigned int size, char *name) {
    int i;
    printf("%s: ", name);
    for (i = 0; i < size; i++) {
	printf("%2x|", array[i]);
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x518a2(%rip), %rdi     # 0x5b0c0
movb $0x0, %al
callq 0x1050
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x9859
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x5187e(%rip), %rdi     # 0x5b0c5
movb $0x0, %al
callq 0x1050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x982c
leaq 0x517e8(%rip), %rdi     # 0x5b048
movb $0x0, %al
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/groestl.c
// Function: groestl_small_init
static void
groestl_small_init(sph_groestl_small_context *sc, unsigned out_size)
{
	size_t u;

	sc->ptr = 0;
#if SPH_GROESTL_64
	for (u = 0; u < 7; u ++)
		sc->state.wide[u] = 0;
#if USE_LE
	sc->state.wide[7] = ((sph_u64)(out_size & 0xFF) << 56)
		| ((sph_u64)(out_size & 0xFF00) << 40);
#else
	sc->state.wide[7] = (sph_u64)out_size;
#endif
#else
	for (u = 0; u < 15; u ++)
		sc->state.narrow[u] = 0;
#if USE_LE
	sc->state.narrow[15] = ((sph_u32)(out_size & 0xFF) << 24)
		| ((sph_u32)(out_size & 0xFF00) << 8);
#else
	sc->state.narrow[15] = (sph_u32)out_size;
#endif
#endif
#if SPH_64
	sc->count = 0;
#else
	sc->count_high = 0;
	sc->count_low = 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq $0x0, -0x18(%rbp)
cmpq $0x7, -0x18(%rbp)
jae 0x9905
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x48(%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x98df
movl -0xc(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
shlq $0x38, %rcx
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
movl %eax, %eax
shlq $0x28, %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/groestl.c
// Function: groestl_big_init
static void
groestl_big_init(sph_groestl_big_context *sc, unsigned out_size)
{
	size_t u;

	sc->ptr = 0;
#if SPH_GROESTL_64
	for (u = 0; u < 15; u ++)
		sc->state.wide[u] = 0;
#if USE_LE
	sc->state.wide[15] = ((sph_u64)(out_size & 0xFF) << 56)
		| ((sph_u64)(out_size & 0xFF00) << 40);
#else
	sc->state.wide[15] = (sph_u64)out_size;
#endif
#else
	for (u = 0; u < 31; u ++)
		sc->state.narrow[u] = 0;
#if USE_LE
	sc->state.narrow[31] = ((sph_u32)(out_size & 0xFF) << 24)
		| ((sph_u32)(out_size & 0xFF00) << 8);
#else
	sc->state.narrow[31] = (sph_u32)out_size;
#endif
#endif
#if SPH_64
	sc->count = 0;
#else
	sc->count_high = 0;
	sc->count_low = 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
movq $0x0, -0x18(%rbp)
cmpq $0xf, -0x18(%rbp)
jae 0xd3ab
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x88(%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd382
movl -0xc(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
shlq $0x38, %rcx
movl -0xc(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
movl %eax, %eax
shlq $0x28, %rax
orq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x108(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/blake.c
// Function: blake32_init
static void
blake32_init(sph_blake_small_context *sc,
	const sph_u32 *iv, const sph_u32 *salt)
{
	memcpy(sc->H, iv, 8 * sizeof(sph_u32));
	memcpy(sc->S, salt, 4 * sizeof(sph_u32));
	sc->T0 = sc->T1 = 0;
	sc->ptr = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x48(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x50(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x58(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x68(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x70(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x7c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x78(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/blake.c
// Function: blake64_init
static void
blake64_init(sph_blake_big_context *sc,
	const sph_u64 *iv, const sph_u64 *salt)
{
	memcpy(sc->H, iv, 8 * sizeof(sph_u64));
	memcpy(sc->S, salt, 4 * sizeof(sph_u64));
	sc->T0 = sc->T1 = 0;
	sc->ptr = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0xc8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0xd0(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0xd8(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xe8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x80(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/bmw.c
// Function: bmw32
static void
bmw32(sph_bmw_small_context *sc, const void *data, size_t len)
{
	unsigned char *buf;
	size_t ptr;
	sph_u32 htmp[16];
	sph_u32 *h1, *h2;
#if !SPH_64
	sph_u32 tmp;
#endif

#if SPH_64
	sc->bit_count += (sph_u64)len << 3;
#else
	tmp = sc->bit_count_low;
	sc->bit_count_low = SPH_T32(tmp + ((sph_u32)len << 3));
	if (sc->bit_count_low < tmp)
		sc->bit_count_high ++;
	sc->bit_count_high += len >> 29;
#endif
	buf = sc->buf;
	ptr = sc->ptr;
	h1 = sc->H;
	h2 = htmp;
	while (len > 0) {
		size_t clen;

		clen = (sizeof sc->buf) - ptr;
		if (clen > len)
			clen = len;
		memcpy(buf + ptr, data, clen);
		data = (const unsigned char *)data + clen;
		len -= clen;
		ptr += clen;
		if (ptr == sizeof sc->buf) {
			sph_u32 *ht;

			compress_small(buf, h1, h2);
			ht = h1;
			h1 = h2;
			h2 = ht;
			ptr = 0;
		}
	}
	sc->ptr = ptr;
	if (h1 != sc->H)
		memcpy(sc->H, h1, sizeof sc->H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
movq -0x8(%rbp), %rax
addq 0x88(%rax), %rcx
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x27ee7
movl $0x40, %eax
subq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x27e5c
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x1080
movq -0x10(%rbp), %rax
addq -0x88(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x88(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x88(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x40, -0x28(%rbp)
jne 0x27ee2
movq -0x20(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x287b0
movq -0x78(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x80(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x27e29
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x78(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x48, %rcx
cmpq %rcx, %rax
je 0x27f1a
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movq -0x78(%rbp), %rsi
movl $0x40, %edx
callq 0x1080
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/bmw.c
// Function: bmw64
static void
bmw64(sph_bmw_big_context *sc, const void *data, size_t len)
{
	unsigned char *buf;
	size_t ptr;
	sph_u64 htmp[16];
	sph_u64 *h1, *h2;

	sc->bit_count += (sph_u64)len << 3;
	buf = sc->buf;
	ptr = sc->ptr;
	h1 = sc->H;
	h2 = htmp;
	while (len > 0) {
		size_t clen;

		clen = (sizeof sc->buf) - ptr;
		if (clen > len)
			clen = len;
		memcpy(buf + ptr, data, clen);
		data = (const unsigned char *)data + clen;
		len -= clen;
		ptr += clen;
		if (ptr == sizeof sc->buf) {
			sph_u64 *ht;

			compress_big(buf, h1, h2);
			ht = h1;
			h1 = h2;
			h2 = ht;
			ptr = 0;
		}
	}
	sc->ptr = ptr;
	if (h1 != sc->H)
		memcpy(sc->H, h1, sizeof sc->H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
movq -0x8(%rbp), %rax
addq 0x108(%rax), %rcx
movq %rcx, 0x108(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x88, %rax
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x2843a
movl $0x80, %eax
subq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x2839a
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0xc8(%rbp), %rdx
callq 0x1080
movq -0x10(%rbp), %rax
addq -0xc8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0xc8(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0xc8(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x80, -0x28(%rbp)
jne 0x28435
movq -0x20(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x2e9b0
movq -0xb8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x28367
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0xb8(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x88, %rcx
cmpq %rcx, %rax
je 0x2847c
movq -0x8(%rbp), %rdi
addq $0x88, %rdi
movq -0xb8(%rbp), %rsi
movl $0x80, %edx
callq 0x1080
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rb-de0[P]hashverifier-for-monacoin/Lyra2RE/skein.c
// Function: skein_big_init
static void
skein_big_init(sph_skein_big_context *sc, const sph_u64 *iv)
{
	sc->h0 = iv[0];
	sc->h1 = iv[1];
	sc->h2 = iv[2];
	sc->h3 = iv[3];
	sc->h4 = iv[4];
	sc->h5 = iv[5];
	sc->h6 = iv[6];
	sc->h7 = iv[7];
	sc->bcount = 0;
	sc->ptr = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aescopav2/ref/aes-core.c
// Function: aesc_encrypt
void aesc_encrypt(const uint8_t plain_text[], uint8_t cipher_text[], const uint8_t key_sched[])
{
	uint8_t state[16];
	
	unsigned int i;
	
	aes_first_addroundkey(state, plain_text, key_sched);
	
	for (i = 1; i < 10; ++i) {
		aes_subbyte_shiftrows_mixcols(state);
		aes_addroundkey(state, key_sched + i * 16);
	}
	
	aes_subbytes_shiftrows(state);
	aes_last_addroundkey(cipher_text, state, key_sched + 10 * 16);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1070
movl $0x1, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jae 0x1d38
leaq 0x10(%rsp), %rdi
callq 0x1040
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %eax
shll $0x4, %eax
movl %eax, %eax
addq %rax, %rsi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1cff
leaq 0x10(%rsp), %rdi
callq 0x10e0
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0xa0, %rdx
callq 0x10c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aescopav2/ref/aes-core.c
// Function: aesc_decrypt
void aesc_decrypt(const uint8_t cipher_text[], uint8_t plain_text[], const uint8_t key_sched[])
{
	uint8_t state[16];
	
	unsigned int i;
	
	aes_first_addroundkey(state, cipher_text, key_sched + 10 * 16);
	aes_isubbytes_ishiftrows(state);
	
	for (i = 9; i > 0; --i) {
		aes_addroundkey(state, key_sched + i * 16);
		aes_isubbyte_ishiftrows_imixcols(state);
	}
	
	aes_last_addroundkey(plain_text, state, key_sched);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq $0xa0, %rdx
callq 0x1070
leaq 0x10(%rsp), %rdi
callq 0x1170
movl $0x9, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jbe 0x2639
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %eax
shll $0x4, %eax
movl %eax, %eax
addq %rax, %rsi
callq 0x1030
leaq 0x10(%rsp), %rdi
callq 0x10b0
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2600
movq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x10c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aescopav2/ref/encrypt.c
// Function: mac
void mac(unsigned char* out, 
		const unsigned char* in, unsigned long long len, 
		const unsigned char* LL,
		const unsigned char* k)
{
	block_t v = { 0 }, delta, block;
	unsigned int i;

	gf128_mul3(delta, LL);
	gf128_mul3(delta, delta);
	gf128_mul3(delta, delta); /* delta = 3^3*L */

	/* mac full blocks except last */
	while (len > 16) {
		xor_block(block, in, delta);
		AES_ENCRYPT(block, block, k);
		xor_block(v, v, block);

		gf128_mul2(delta, delta);

		in += 16;
		len -= 16;
	}

	if (len == 16) { /* last block full */
		gf128_mul3(delta, delta);
		xor_block(v, v, delta);
		xor_block(v, v, in);
		AES_ENCRYPT(out, v, k);
	} else { /* last block partial */
		gf128_mul3(delta, delta);
		gf128_mul3(delta, delta);
		xor_block(v, v, delta);
		for (i = 0; i < len; i++) {
			v[i] ^= in[i];
		}
		v[len] ^= 0x80; /* padding */
		AES_ENCRYPT(out, v, k);
	}
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1060
leaq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2950
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2950
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2950
cmpq $0x10, 0x50(%rsp)
jbe 0x285c
leaq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2990
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x1150
leaq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2990
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x29f0
movq 0x58(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x50(%rsp)
jmp 0x27eb
cmpq $0x10, 0x50(%rsp)
jne 0x28b4
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2950
leaq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2990
leaq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x2990
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x1150
jmp 0x294a
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2950
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2950
leaq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x2990
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpq 0x50(%rsp), %rax
jae 0x2922
movq 0x58(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %edx
movl 0xc(%rsp), %eax
movzbl 0x30(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x30(%rsp,%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x28ee
movq 0x50(%rsp), %rax
movzbl 0x30(%rsp,%rax), %ecx
xorl $0x80, %ecx
movb %cl, 0x30(%rsp,%rax)
movq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x1150
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aescopav2/ref/encrypt.c
// Function: gf128_mul2
static void gf128_mul2(block_t res, const block_t x)
{
	int msb = x[0] & 0x80;
	shl_block(res, x);
	if (msb) {
		res[15] ^= 0x87;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3670
cmpl $0x0, 0x4(%rsp)
je 0x2a37
movq 0x10(%rsp), %rax
movzbl 0xf(%rax), %ecx
xorl $0x87, %ecx
movb %cl, 0xf(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aescopav2/ref/encrypt.c
// Function: gf128_mul7
static void gf128_mul7(block_t res, const block_t x)
{
	block_t x2, x4;

	gf128_mul2(x2, x);
	gf128_mul2(x4, x2);
	xor_block(x4, x4, x2);
	xor_block(res, x4, x);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x29f0
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x29f0
movq %rsp, %rdi
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
callq 0x2990
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
movq 0x28(%rsp), %rdx
callq 0x2990
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aescopav2/ref/encrypt.c
// Function: shl_block
static void shl_block(block_t res, const block_t x)
{
	int i;
	for (i = 0; i < 15; i++) {
		res[i] = (x[i] << 1) | (x[i+1] >> 7);
	}
	res[15] = x[15] << 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xf, -0x14(%rsp)
jge 0x36cd
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movzbl (%rax,%rcx), %eax
shll %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x7, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movslq -0x14(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3682
movq -0x10(%rsp), %rax
movzbl 0xf(%rax), %eax
shll %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0xf(%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: binary_to_decimal
int binary_to_decimal(mpz_t input, int start, int end) {
    int i;
    int result = 0;
    int g = 1;
    for(i = end; i<=start; i++) {
        int bit = mpz_tstbit(input, i);
        if(bit) {
            result += g * bit;
        }
        g <<= 1;
    }
    return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x2395
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x80b0
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
je 0x237e
movl 0xc(%rsp), %eax
imull 0x8(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2349
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: montgomery_Mp
void montgomery_Mp(mpz_t output, mpz_t N, mpz_t BASE) {
    mpz_t temporary;
    mpz_init_set_ui(temporary, 1);
    while(mpz_cmp(temporary, N) <= 0) {
        mpz_mul(temporary, temporary, BASE);
    }
    mpz_init_set(output, temporary);
    mpz_clear(temporary);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsp, %rdi
movl $0x1, %esi
callq 0x4d20
movq %rsp, %rdi
movq 0x18(%rsp), %rsi
callq 0x4490
cmpl $0x0, %eax
jg 0x27a4
movq %rsp, %rdi
movq %rsp, %rsi
movq 0x10(%rsp), %rdx
callq 0x4ed0
jmp 0x2780
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x4cc0
movq %rsp, %rdi
callq 0x4460
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: montgomery_Mw
void montgomery_Mw(mpz_t output, mpz_t N, mpz_t BASE) {
    mpz_t temporary;
    mpz_init_set_ui(temporary, 1);
    int i;
    for(i = 1; i < W-1; i++) {
        // t <- t*t*N (mod b)
        mpz_mul(temporary, temporary, temporary);
        mpz_mod(temporary, temporary, BASE);
        mpz_mul(temporary, temporary, N);
        mpz_mod(temporary, temporary, BASE);
    }
    // t = -t (mod b)
    mpz_neg(temporary, temporary);
    mpz_add(temporary, temporary, BASE);

    mpz_init_set(output, temporary);
    mpz_clear(temporary);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4d20
movl $0x1, 0xc(%rsp)
cmpl $0x3f, 0xc(%rsp)
jge 0x284e
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4ed0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4d60
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x4ed0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4d60
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x27ea
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x53a0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x40c0
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4cc0
leaq 0x10(%rsp), %rdi
callq 0x4460
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: montgomery_Mp_sq
void montgomery_Mp_sq(mpz_t output, mpz_t N) {
    mpz_t temporary;
    mpz_init_set_ui(temporary, 1);
    int lN = mpz_size(N);
    int i;

    for(i = 1; i <= 2*lN*W; i++) {
        // t <- t + t (mod N)
        mpz_add(temporary, temporary, temporary);
        mpz_mod(temporary, temporary, N);
    }

    mpz_init_set(output, temporary);
    mpz_clear(temporary);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4d20
movq 0x28(%rsp), %rdi
callq 0x7110
movl %eax, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
shll %ecx
shll $0x6, %ecx
cmpl %ecx, %eax
jg 0x2909
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x40c0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x4d60
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x28c3
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4cc0
leaq 0x10(%rsp), %rdi
callq 0x4460
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: montgomery_multiplication
void montgomery_multiplication(mpz_t output,
                               mpz_t x,
                               mpz_t y,
                               mpz_t BASE,
                               mpz_t N,
                               mpz_t Mw) {
    mpz_t temporary;

    // r <- 0
    mpz_init(temporary);
    mpz_init_set_ui(temporary, 0);
    int i;
    int lN = mpz_size(N);

    mpz_t u;
    mpz_init(u);

    mpz_t t1, t2;
    mpz_init(t1);
    mpz_init(t2);

    mp_limb_t temp;
    mp_limb_t w = mpz_getlimbn(Mw, 0);

    for(i = 0; i < lN ; i++) {
        temp = mpz_getlimbn(temporary, 0) + mpz_getlimbn(y, i) * mpz_getlimbn(x, 0);
        temp = temp * w;

        mpz_set_ui(u, temp);

        mpz_mul_ui(t1, x, mpz_getlimbn(y, i));
        mpz_mul(t2, u, N);

        mpz_add(temporary, temporary, t1);
        mpz_add(temporary, temporary, t2);

        mpz_div(temporary, temporary, BASE);
    }

    if(mpz_cmp(temporary, N) > 0) {
        mpz_sub(temporary, temporary, N);
    }

    mpz_init_set(output, temporary);
    mpz_clear(temporary);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq %r9, 0x88(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4a80
leaq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d20
movq 0x90(%rsp), %rdi
callq 0x7110
movl %eax, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4a80
leaq 0x40(%rsp), %rdi
callq 0x4a80
leaq 0x30(%rsp), %rdi
callq 0x4a80
movq 0x88(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4660
movq %rax, 0x20(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
cmpl 0x68(%rsp), %eax
jge 0x2aec
leaq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4660
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x4660
movq %rax, (%rsp)
movq 0xa8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4660
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
imulq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x70c0
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x4660
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x52f0
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x4ed0
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x40c0
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x40c0
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x4510
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x29cc
leaq 0x70(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x4490
cmpl $0x0, %eax
jle 0x2b1a
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x7130
movq 0xb0(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4cc0
leaq 0x70(%rsp), %rdi
callq 0x4460
addq $0xb8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: montgomery
void montgomery(mpz_t output, mpz_t x, mpz_t y, mpz_t N) {
    // Calculate BASE value
    // BASE = 2^64
    mpz_t BASE;
    mpz_init_set_ui(BASE, 2);
    mpz_pow_ui(BASE, BASE, W);

    // Montgomery parameters
    mpz_t Mp;
    mpz_t Mw;
    mpz_t Mp_sq;

    mpz_t Mx;
    mpz_t My;

    mpz_t one;
    mpz_init_set_ui(one, 1);

    mpz_t temporary;

    // Compute Montgomery parameters.
    montgomery_Mp(Mp, N, BASE);
    montgomery_Mw(Mw, N, BASE);
    montgomery_Mp_sq(Mp_sq, N);

    montgomery_multiplication(Mx, x, Mp_sq, BASE, N, Mw);
    montgomery_multiplication(My, y, Mp_sq, BASE, N, Mw);
    montgomery_multiplication(temporary, Mx, My, BASE, N, Mw);
    montgomery_multiplication(temporary, temporary, one, BASE, N, Mw);

    mpz_init_set(output, temporary);

    mpz_clear(temporary);
    mpz_clear(Mp);
    mpz_clear(Mw);
    mpz_clear(Mp_sq);
    mpz_clear(Mx);
    mpz_clear(My);
    mpz_clear(one);
    mpz_clear(BASE);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x2, %esi
callq 0x4d20
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl $0x40, %edx
callq 0x5410
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x4d20
leaq 0x60(%rsp), %rdi
movq 0x88(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x2760
leaq 0x50(%rsp), %rdi
movq 0x88(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x27c0
leaq 0x40(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x2890
leaq 0x30(%rsp), %rdi
movq 0x98(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq 0x88(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x2930
leaq 0x20(%rsp), %rdi
movq 0x90(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq 0x88(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x2930
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq 0x88(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x2930
movq %rsp, %rdi
movq %rsp, %rsi
leaq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rcx
movq 0x88(%rsp), %r8
leaq 0x50(%rsp), %r9
callq 0x2930
movq 0xa0(%rsp), %rdi
movq %rsp, %rsi
callq 0x4cc0
movq %rsp, %rdi
callq 0x4460
leaq 0x60(%rsp), %rdi
callq 0x4460
leaq 0x50(%rsp), %rdi
callq 0x4460
leaq 0x40(%rsp), %rdi
callq 0x4460
leaq 0x30(%rsp), %rdi
callq 0x4460
leaq 0x20(%rsp), %rdi
callq 0x4460
leaq 0x10(%rsp), %rdi
callq 0x4460
leaq 0x70(%rsp), %rdi
callq 0x4460
addq $0xa8, %rsp
retq
nopw (%rax,%rax)