LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]oatk/kthread.c
// Function: kt_pipeline
void kt_pipeline(int n_threads, void *(*func)(void*, int, void*), void *shared_data, int n_steps)
{
	ktp_t aux;
	pthread_t *tid;
	int i;

	if (n_threads < 1) n_threads = 1;
	aux.n_workers = n_threads;
	aux.n_steps = n_steps;
	aux.func = func;
	aux.shared = shared_data;
	aux.index = 0;
	pthread_mutex_init(&aux.mutex, 0);
	pthread_cond_init(&aux.cv, 0);

	aux.workers = (ktp_worker_t*)alloca(n_threads * sizeof(ktp_worker_t));
	for (i = 0; i < n_threads; ++i) {
		ktp_worker_t *w = &aux.workers[i];
		w->step = 0; w->pl = &aux; w->data = 0;
		w->index = aux.index++;
	}

	tid = (pthread_t*)alloca(n_threads * sizeof(pthread_t));
	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktp_worker, &aux.workers[i]);
	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);

	pthread_mutex_destroy(&aux.mutex);
	pthread_cond_destroy(&aux.cv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpl $0x2, %edi
pushq $0x1
popq %r14
cmovgel %edi, %r14d
leaq -0x88(%rbp), %rdi
movl %r14d, -0x10(%rdi)
movl %ecx, -0xc(%rdi)
movq %rsi, -0x20(%rdi)
movq %rdx, -0x28(%rdi)
andq $0x0, -0x18(%rdi)
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x23d0
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x2250
movq %r14, %r13
shlq $0x5, %r13
movq %rsp, %rax
subq %r13, %rax
movq %rax, %rsp
movq %rax, -0x30(%r15)
movq -0x40(%r15), %rcx
leaq -0xb0(%rbp), %rdx
cmpq %rbx, %r13
je 0x5b68
andl $0x0, 0x10(%rax,%rbx)
movq %rdx, (%rax,%rbx)
andq $0x0, 0x18(%rax,%rbx)
movq %rcx, 0x8(%rax,%rbx)
incq %rcx
addq $0x20, %rbx
jmp 0x5b46
movq %rcx, -0xa0(%rbp)
movq %rsp, %rbx
movq %r14, -0x30(%rbp)
leaq 0xf(,%r14,8), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
xorl %r14d, %r14d
leaq 0x69(%rip), %r15        # 0x5bfb
movq %rbx, %r12
cmpq %r14, %r13
je 0x5bbb
movq -0x90(%rbp), %rcx
addq %r14, %rcx
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x22e0
addq $0x20, %r14
addq $0x8, %r12
jmp 0x5b95
xorl %r14d, %r14d
movq -0x30(%rbp), %r15
cmpq %r14, %r15
je 0x5bd7
movq (%rbx,%r14,8), %rdi
xorl %esi, %esi
callq 0x23a0
incq %r14
jmp 0x5bc2
leaq -0x88(%rbp), %rdi
callq 0x2150
leaq -0x60(%rbp), %rdi
callq 0x2300
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: toBitInterleaving
void toBitInterleaving(UINT32 low, UINT32 high, UINT32 *even, UINT32 *odd)
{
    unsigned int i;

    *even = 0;
    *odd = 0;
    for(i=0; i<64; i++) {
        unsigned int inBit;
        if (i < 32)
            inBit = (low >> i) & 1;
        else
            inBit = (high >> (i-32)) & 1;
        if ((i % 2) == 0)
            *even |= inBit << (i/2);
        else
            *odd |= inBit << ((i-1)/2);
    }
}

// Assembly:
andl $0x0, (%rdx)
andl $0x0, (%rcx)
xorl %eax, %eax
cmpl $0x40, %eax
je 0x58d6
movl %eax, %r8d
subl $0x20, %r8d
shrxl %eax, %edi, %r9d
shrxl %r8d, %esi, %r10d
cmovbl %r9d, %r10d
andl $0x1, %r10d
movl %eax, %r9d
andl $0x1fe, %r9d            # imm = 0x1FE
testb $0x1, %al
movq %rdx, %rax
cmovneq %rcx, %rax
shrl %r9d
shlxl %r9d, %r10d, %r9d
orl %r9d, (%rax)
leal 0x21(%r8), %eax
jmp 0x5894
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: fromBitInterleaving
void fromBitInterleaving(UINT32 even, UINT32 odd, UINT32 *low, UINT32 *high)
{
    unsigned int i;

    *low = 0;
    *high = 0;
    for(i=0; i<64; i++) {
        unsigned int inBit;
        if ((i % 2) == 0)
            inBit = (even >> (i/2)) & 1;
        else
            inBit = (odd >> ((i-1)/2)) & 1;
        if (i < 32)
            *low |= inBit << i;
        else
            *high |= inBit << (i-32);
    }
}

// Assembly:
andl $0x0, (%rdx)
andl $0x0, (%rcx)
xorl %eax, %eax
cmpl $0x40, %eax
je 0x5923
movl %eax, %r8d
andl $0x1fe, %r8d            # imm = 0x1FE
testb $0x1, %al
movl %edi, %r9d
cmovnel %esi, %r9d
shrl %r8d
shrxl %r8d, %r9d, %r8d
andl $0x1, %r8d
movl %eax, %r9d
subl $0x20, %r9d
movq %rcx, %r10
cmovbq %rdx, %r10
cmovael %r9d, %eax
shlxl %eax, %r8d, %eax
orl %eax, (%r10)
leal 0x21(%r9), %eax
jmp 0x58df
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_AddByte
void KeccakP1600_AddByte(void *state, unsigned char byte, unsigned int offset)
{
    unsigned char data[1];

    assert(offset < 200);
    data[0] = byte;
    KeccakP1600_AddBytes(state, data, offset, 1);
}

// Assembly:
pushq %rax
cmpl $0xc8, %edx
jae 0x5975
leaq 0x7(%rsp), %rax
movb %sil, (%rax)
pushq $0x1
popq %rcx
movq %rax, %rsi
callq 0x56a0
popq %rax
retq
leaq 0x9684(%rip), %rdi      # 0xf000
leaq 0x968a(%rip), %rsi      # 0xf00d
leaq 0x96c9(%rip), %rcx      # 0xf053
movl $0xc4, %edx
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_AddBytes
void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int lanePosition = offset/8;
    unsigned int offsetInLane = offset%8;

    assert(offset < 200);
    assert(offset+length <= 200);
    while(length > 0) {
        unsigned int bytesInLane = 8 - offsetInLane;
        if (bytesInLane > length)
            bytesInLane = length;
        KeccakP1600_AddBytesInLane(state, lanePosition, data, offsetInLane, bytesInLane);
        length -= bytesInLane;
        lanePosition++;
        offsetInLane = 0;
        data += bytesInLane;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xc8, %edx
jae 0x5a03
movl %ecx, %ebx
movl %edx, %ecx
leal (%rbx,%rcx), %eax
cmpl $0xc8, %eax
ja 0x5a22
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %ebp
shrl $0x3, %ebp
andl $0x7, %ecx
pushq $0x8
popq %r13
testl %ebx, %ebx
je 0x59f4
movl %r13d, %r12d
subl %ecx, %r12d
cmpl %ebx, %r12d
cmovael %ebx, %r12d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %r12d, %r8d
callq 0x54c0
subl %r12d, %ebx
incl %ebp
addq %r12, %r14
xorl %ecx, %ecx
jmp 0x59c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x95f6(%rip), %rdi      # 0xf000
leaq 0x95fc(%rip), %rsi      # 0xf00d
leaq 0x9679(%rip), %rcx      # 0xf091
movl $0xe9, %edx
callq 0x51b0
leaq 0x96bd(%rip), %rdi      # 0xf0e6
leaq 0x95dd(%rip), %rsi      # 0xf00d
leaq 0x965a(%rip), %rcx      # 0xf091
movl $0xea, %edx
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_AddBytesInLane
void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
    if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
        UINT8 laneAsBytes[8];
        UINT32 low, high;
        UINT32 lane[2];
        UINT32 *stateAsHalfLanes;

        memset(laneAsBytes, 0, 8);
        memcpy(laneAsBytes+offset, data, length);
        low = laneAsBytes[0]
            | ((UINT32)(laneAsBytes[1]) << 8)
            | ((UINT32)(laneAsBytes[2]) << 16)
            | ((UINT32)(laneAsBytes[3]) << 24);
        high = laneAsBytes[4]
            | ((UINT32)(laneAsBytes[5]) << 8)
            | ((UINT32)(laneAsBytes[6]) << 16)
            | ((UINT32)(laneAsBytes[7]) << 24);
        toBitInterleaving(low, high, lane, lane+1);
        stateAsHalfLanes = (UINT32*)state;
        stateAsHalfLanes[lanePosition*2+0] ^= lane[0];
        stateAsHalfLanes[lanePosition*2+1] ^= lane[1];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
cmpl $0x19, %esi
setae %al
cmpl $0x8, %ecx
setae %sil
orb %al, %sil
leal (%r8,%rcx), %eax
cmpl $0x9, %eax
setae %al
orb %sil, %al
jne 0x5aa9
movq %rdi, %r14
andq $0x0, (%rsp)
movl %ecx, %eax
leaq (%rsp,%rax), %rdi
movl %r8d, %eax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5750
movl (%rsp), %edi
movl 0x4(%rsp), %esi
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5080
addl %ebx, %ebx
movq (%r15), %rax
xorq %rax, (%r14,%rbx,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_OverwriteBytesInLane
void KeccakP1600_OverwriteBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
    if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
        UINT8 laneAsBytes[8];
        UINT32 low, high;
        UINT32 lane[2];
        UINT32 *stateAsHalfLanes;

        KeccakP1600_ExtractBytesInLane(state, lanePosition, laneAsBytes, 0, 8);
        memcpy(laneAsBytes+offset, data, length);
        low = laneAsBytes[0]
            | ((UINT32)(laneAsBytes[1]) << 8)
            | ((UINT32)(laneAsBytes[2]) << 16)
            | ((UINT32)(laneAsBytes[3]) << 24);
        high = laneAsBytes[4]
            | ((UINT32)(laneAsBytes[5]) << 8)
            | ((UINT32)(laneAsBytes[6]) << 16)
            | ((UINT32)(laneAsBytes[7]) << 24);
        toBitInterleaving(low, high, lane, lane+1);
        stateAsHalfLanes = (UINT32*)state;
        stateAsHalfLanes[lanePosition*2+0] = lane[0];
        stateAsHalfLanes[lanePosition*2+1] = lane[1];
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r12d
movl %ecx, %r13d
cmpl $0x19, %esi
setae %al
cmpl $0x8, %ecx
setae %cl
orb %al, %cl
leal (%r12,%r13), %eax
cmpl $0x9, %eax
setae %al
orb %cl, %al
jne 0x5b35
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rsp), %rbp
pushq $0x8
popq %r8
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x5030
movl %r13d, %eax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
movl %r12d, %edx
movq %r15, %rsi
callq 0x5750
movl (%rbp), %edi
movl 0x4(%rbp), %esi
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5080
addl %ebx, %ebx
movq (%r15), %rax
movq %rax, (%r14,%rbx,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_ExtractBytesInLane
void KeccakP1600_ExtractBytesInLane(const void *state, unsigned int lanePosition, unsigned char *data, unsigned int offset, unsigned int length)
{
    if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
        UINT32 *stateAsHalfLanes = (UINT32*)state;
        UINT32 lane[2];
        UINT8 laneAsBytes[8];
        fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], lane, lane+1);
        laneAsBytes[0] = lane[0] & 0xFF;
        laneAsBytes[1] = (lane[0] >> 8) & 0xFF;
        laneAsBytes[2] = (lane[0] >> 16) & 0xFF;
        laneAsBytes[3] = (lane[0] >> 24) & 0xFF;
        laneAsBytes[4] = lane[1] & 0xFF;
        laneAsBytes[5] = (lane[1] >> 8) & 0xFF;
        laneAsBytes[6] = (lane[1] >> 16) & 0xFF;
        laneAsBytes[7] = (lane[1] >> 24) & 0xFF;
        memcpy(data, laneAsBytes+offset, length);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movl %ecx, %r15d
cmpl $0x19, %esi
setae %al
cmpl $0x8, %ecx
setae %cl
orb %al, %cl
leal (%r14,%r15), %eax
cmpl $0x9, %eax
setae %al
orb %cl, %al
jne 0x5bb3
movq %rdx, %rbx
leal (%rsi,%rsi), %eax
movl (%rdi,%rax,4), %eax
movl %esi, %ecx
movl 0x4(%rdi,%rcx,8), %esi
leaq 0xc(%rsp), %rcx
leaq 0x8(%rsp), %r12
movl %eax, %edi
movq %r12, %rdx
callq 0x5690
movq (%r12), %rax
movq %rax, 0x10(%rsp)
movl %r15d, %eax
leaq (%rsp,%rax), %rsi
addq $0x10, %rsi
movl %r14d, %edx
movq %rbx, %rdi
callq 0x5750
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_OverwriteBytes
void KeccakP1600_OverwriteBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int lanePosition = offset/8;
    unsigned int offsetInLane = offset%8;

    assert(offset < 200);
    assert(offset+length <= 200);
    while(length > 0) {
        unsigned int bytesInLane = 8 - offsetInLane;
        if (bytesInLane > length)
            bytesInLane = length;
        KeccakP1600_OverwriteBytesInLane(state, lanePosition, data, offsetInLane, bytesInLane);
        length -= bytesInLane;
        lanePosition++;
        offsetInLane = 0;
        data += bytesInLane;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xc8, %edx
jae 0x5c2e
movl %ecx, %ebx
movl %edx, %ecx
leal (%rbx,%rcx), %eax
cmpl $0xc8, %eax
ja 0x5c4d
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %ebp
shrl $0x3, %ebp
andl $0x7, %ecx
pushq $0x8
popq %r13
testl %ebx, %ebx
je 0x5c1f
movl %r13d, %r12d
subl %ecx, %r12d
cmpl %ebx, %r12d
cmovael %ebx, %r12d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %r12d, %r8d
callq 0x5510
subl %r12d, %ebx
incl %ebp
addq %r12, %r14
xorl %ecx, %ecx
jmp 0x5bf2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x93cb(%rip), %rdi      # 0xf000
leaq 0x93d1(%rip), %rsi      # 0xf00d
leaq 0x94b8(%rip), %rcx      # 0xf0fb
movl $0x119, %edx            # imm = 0x119
callq 0x51b0
leaq 0x9492(%rip), %rdi      # 0xf0e6
leaq 0x93b2(%rip), %rsi      # 0xf00d
leaq 0x9499(%rip), %rcx      # 0xf0fb
movl $0x11a, %edx            # imm = 0x11A
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_OverwriteWithZeroes
void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
{
    UINT8 laneAsBytes[8];
    unsigned int lanePosition = 0;

    assert(byteCount <= 200);
    memset(laneAsBytes, 0, 8);
    while(byteCount > 0) {
        if (byteCount < 8) {
            KeccakP1600_OverwriteBytesInLane(state, lanePosition, laneAsBytes, 0, byteCount);
            byteCount = 0;
        }
        else {
            UINT32 *stateAsHalfLanes = (UINT32*)state;
            stateAsHalfLanes[lanePosition*2+0] = 0;
            stateAsHalfLanes[lanePosition*2+1] = 0;
            byteCount -= 8;
            lanePosition++;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0xc9, %esi
jae 0x5ccf
movl %esi, %r8d
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
xorl %r15d, %r15d
testl %r8d, %r8d
je 0x5cc5
cmpl $0x7, %r8d
ja 0x5caf
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x5510
xorl %r8d, %r8d
jmp 0x5c8f
leal (%r15,%r15), %eax
andl $0x0, (%rbx,%rax,4)
andl $0x0, 0x4(%rbx,%rax,4)
addl $-0x8, %r8d
incl %r15d
jmp 0x5c8f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9480(%rip), %rdi      # 0xf156
leaq 0x9330(%rip), %rsi      # 0xf00d
leaq 0x9483(%rip), %rcx      # 0xf167
movl $0x12e, %edx            # imm = 0x12E
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_ExtractBytes
void KeccakP1600_ExtractBytes(const void *state, unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int lanePosition = offset/8;
    unsigned int offsetInLane = offset%8;

    assert(offset < 200);
    assert(offset+length <= 200);
    while(length > 0) {
        unsigned int bytesInLane = 8 - offsetInLane;
        if (bytesInLane > length)
            bytesInLane = length;
        KeccakP1600_ExtractBytesInLane(state, lanePosition, data, offsetInLane, bytesInLane);
        length -= bytesInLane;
        lanePosition++;
        offsetInLane = 0;
        data += bytesInLane;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xc8, %edx
jae 0x5d9d
movl %ecx, %ebx
movl %edx, %ecx
leal (%rbx,%rcx), %eax
cmpl $0xc8, %eax
ja 0x5dbc
movq %rsi, %r14
movq %rdi, %r15
movl %ecx, %ebp
shrl $0x3, %ebp
andl $0x7, %ecx
pushq $0x8
popq %r13
testl %ebx, %ebx
je 0x5d8e
movl %r13d, %r12d
subl %ecx, %r12d
cmpl %ebx, %r12d
cmovael %ebx, %r12d
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl %r12d, %r8d
callq 0x5030
subl %r12d, %ebx
incl %ebp
addq %r12, %r14
xorl %ecx, %ecx
jmp 0x5d61
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x925c(%rip), %rdi      # 0xf000
leaq 0x9262(%rip), %rsi      # 0xf00d
leaq 0x93f0(%rip), %rcx      # 0xf1a2
movl $0x201, %edx            # imm = 0x201
callq 0x51b0
leaq 0x9323(%rip), %rdi      # 0xf0e6
leaq 0x9243(%rip), %rsi      # 0xf00d
leaq 0x93d1(%rip), %rcx      # 0xf1a2
movl $0x202, %edx            # imm = 0x202
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: ROL64
void ROL64(UINT32 inEven, UINT32 inOdd, UINT32 *outEven, UINT32 *outOdd, unsigned int offset)
{
    if ((offset % 2) == 0) {
        *outEven = ROL32(inEven, offset/2);
        *outOdd = ROL32(inOdd, offset/2);
    }
    else {
        *outEven = ROL32(inOdd, (offset+1)/2);
        *outOdd = ROL32(inEven, (offset-1)/2);
    }
}

// Assembly:
movl %r8d, %eax
testb $0x1, %r8b
jne 0x61bb
shrl %eax
shlxl %eax, %edi, %r9d
shlxl %eax, %esi, %r10d
negb %al
shrxl %eax, %edi, %r11d
xorl %r9d, %r11d
shrxl %eax, %esi, %eax
xorl %r10d, %eax
testl %r8d, %r8d
cmovel %edi, %r11d
movl %r11d, (%rdx)
cmovel %esi, %eax
movl %eax, %edi
jmp 0x61f1
incl %eax
jne 0x61c7
movl %esi, (%rdx)
pushq $-0x2
popq %r8
jmp 0x61df
shrl %eax
shlxl %eax, %esi, %r9d
negb %al
shrxl %eax, %esi, %eax
xorl %r9d, %eax
movl %eax, (%rdx)
decl %r8d
je 0x61f1
shrl %r8d
shlxl %r8d, %edi, %eax
negb %r8b
shrxl %r8d, %edi, %edi
xorl %eax, %edi
movl %edi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_ExtractAndAddBytesInLane
void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    if ((lanePosition < 25) && (offset < 8) && (offset+length <= 8)) {
        UINT8 laneAsBytes[8];
        unsigned int i;

        KeccakP1600_ExtractBytesInLane(state, lanePosition, laneAsBytes, offset, length);
        for(i=0; i<length; i++)
            output[i] = input[i] ^ laneAsBytes[i];
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %r15d
movq %rcx, %rbx
cmpl $0x19, %esi
setae %al
cmpl $0x8, %r8d
setae %cl
orb %al, %cl
leal (%r15,%r8), %eax
cmpl $0x9, %eax
setae %al
orb %cl, %al
jne 0x624d
movq %rdx, %r14
leaq 0x8(%rsp), %rdx
movl %r8d, %ecx
movl %r15d, %r8d
callq 0x5030
movl %r15d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x624d
movb 0x8(%rsp,%rcx), %dl
xorb (%r14,%rcx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
jmp 0x6238
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_ExtractAndAddBytes
void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int lanePosition = offset/8;
    unsigned int offsetInLane = offset%8;

    assert(offset < 200);
    assert(offset+length <= 200);
    while(length > 0) {
        unsigned int bytesInLane = 8 - offsetInLane;
        if (bytesInLane > length)
            bytesInLane = length;
        KeccakP1600_ExtractAndAddBytesInLane(state, lanePosition, input, output, offsetInLane, bytesInLane);
        length -= bytesInLane;
        lanePosition++;
        offsetInLane = 0;
        input += bytesInLane;
        output += bytesInLane;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0xc8, %ecx
jae 0x62d4
movl %r8d, %ebx
movl %ecx, %r8d
leal (%rbx,%r8), %eax
cmpl $0xc8, %eax
ja 0x62f3
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %r8d, %ebp
shrl $0x3, %ebp
andl $0x7, %r8d
testl %ebx, %ebx
je 0x62c5
pushq $0x8
popq %rax
movl %eax, %r13d
subl %r8d, %r13d
cmpl %ebx, %r13d
cmovael %ebx, %r13d
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
movl %r13d, %r9d
callq 0x5240
subl %r13d, %ebx
incl %ebp
addq %r13, %r15
addq %r13, %r14
xorl %r8d, %r8d
jmp 0x628e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8d25(%rip), %rdi      # 0xf000
leaq 0x8d2b(%rip), %rsi      # 0xf00d
leaq 0x8f12(%rip), %rcx      # 0xf1fb
movl $0x222, %edx            # imm = 0x222
callq 0x51b0
leaq 0x8dec(%rip), %rdi      # 0xf0e6
leaq 0x8d0c(%rip), %rsi      # 0xf00d
leaq 0x8ef3(%rip), %rcx      # 0xf1fb
movl $0x223, %edx            # imm = 0x223
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_DisplayRoundConstants
void KeccakP1600_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%08X:%08X", (unsigned int)(KeccakRoundConstants[i][0]), (unsigned int)(KeccakRoundConstants[i][1]));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8f4a(%rip), %r14      # 0xf271
leaq 0x8f82(%rip), %r13      # 0xf2b0
leaq 0x8f4e(%rip), %r15      # 0xf283
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x18, %r12
je 0x6377
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x5730
movl (%r13,%r12,8), %edx
movl 0x4(%r13,%r12,8), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5730
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5390
incq %r12
jmp 0x633b
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5390
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_DisplayRhoOffsets
void KeccakP1600_DisplayRhoOffsets(FILE *f)
{
    unsigned int x, y;

    for(y=0; y<5; y++) for(x=0; x<5; x++) {
        fprintf(f, "RhoOffset[%i][%i] = ", x, y);
        fprintf(f, "%2i", KeccakRhoOffsets[5*y+x]);
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8fcb(%rip), %r14      # 0xf370
leaq 0x8ef6(%rip), %r15      # 0xf2a2
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x5, %r12
je 0x6401
xorl %r13d, %r13d
cmpq $0x5, %r13
je 0x63f8
movq %rbx, %rdi
leaq 0x8ec2(%rip), %rsi      # 0xf28d
movl %r13d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x5730
movl (%r14,%r13,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5730
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5390
incq %r13
jmp 0x63bb
incq %r12
addq $0x14, %r14
jmp 0x63b2
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5390
nop
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-800-reference.c
// Function: KeccakP800_AddBytes
void KeccakP800_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 100);
    assert(offset+length <= 100);
    for(i=0; i<length; i++)
        ((unsigned char *)state)[offset+i] ^= data[i];
}

// Assembly:
pushq %rax
cmpl $0x64, %edx
jae 0x76a6
leal (%rcx,%rdx), %eax
cmpl $0x64, %eax
ja 0x76c5
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x76a4
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
jmp 0x768e
popq %rax
retq
leaq 0x8317(%rip), %rdi      # 0xf9c4
leaq 0x831d(%rip), %rsi      # 0xf9d1
leaq 0x8394(%rip), %rcx      # 0xfa4f
movl $0x98, %edx
callq 0x51b0
leaq 0x83d7(%rip), %rdi      # 0xfaa3
leaq 0x82fe(%rip), %rsi      # 0xf9d1
leaq 0x8375(%rip), %rcx      # 0xfa4f
movl $0x99, %edx
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-800-reference.c
// Function: KeccakP800_ExtractAndAddBytes
void KeccakP800_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 100);
    assert(offset+length <= 100);
    for(i=0; i<length; i++)
        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
}

// Assembly:
pushq %rax
cmpl $0x64, %ecx
jae 0x7a9f
leal (%r8,%rcx), %eax
cmpl $0x64, %eax
ja 0x7abe
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x7a9d
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
jmp 0x7a83
popq %rax
retq
leaq 0x7f1e(%rip), %rdi      # 0xf9c4
leaq 0x7f24(%rip), %rsi      # 0xf9d1
leaq 0x8101(%rip), %rcx      # 0xfbb5
movl $0x16c, %edx            # imm = 0x16C
callq 0x51b0
leaq 0x7fde(%rip), %rdi      # 0xfaa3
leaq 0x7f05(%rip), %rsi      # 0xf9d1
leaq 0x80e2(%rip), %rcx      # 0xfbb5
movl $0x16d, %edx            # imm = 0x16D
callq 0x51b0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-800-reference.c
// Function: KeccakP800_DisplayRoundConstants
void KeccakP800_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i]));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x813e(%rip), %r13      # 0xfc30
leaq 0x7778(%rip), %r14      # 0xf271
leaq 0x7788(%rip), %r15      # 0xf288
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x16, %r12
je 0x7b40
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x5730
movl (%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5730
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5390
incq %r12
addq $0x4, %r13
jmp 0x7b06
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5390
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayBytes
void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size)
{
    unsigned int i;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<size; i++)
            fprintf(intermediateValueFile, "%02X ", bytes[i]);
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x6c43(%rip), %r15      # 0x14ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe402
movl %ecx, %ebp
movq 0x6c3a(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe402
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x1925(%rip), %rsi      # 0xfcf4
xorl %eax, %eax
callq 0x5730
movl %ebp, %r12d
leaq 0x1919(%rip), %r14      # 0xfcf9
xorl %r13d, %r13d
movq (%r15), %rsi
cmpq %r13, %r12
je 0xe411
movzbl (%rbx,%r13), %edx
movq %rsi, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x5730
incq %r13
jmp 0xe3e3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x5390
movq (%r15), %rsi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5390
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayBits
void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst)
{
    unsigned int i, iByte, iBit;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<size; i++) {
            iByte = i/8;
            iBit = i%8;
            if (MSBfirst)
                fprintf(intermediateValueFile, "%d ", ((data[iByte] << iBit) & 0x80) != 0);
            else
                fprintf(intermediateValueFile, "%d ", ((data[iByte] >> iBit) & 0x01) != 0);
        }
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x6ba9(%rip), %r12      # 0x14ff0
movq (%r12), %rdi
testq %rdi, %rdi
je 0xe4c0
movl %ecx, %ebp
movq 0x6b9f(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe4c0
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %rdx
leaq 0x1887(%rip), %rsi      # 0xfcf4
xorl %eax, %eax
callq 0x5730
leaq 0x1884(%rip), %r15      # 0xfcff
xorl %r13d, %r13d
cmpl %r13d, %ebp
je 0xe4cf
movl %r13d, %ecx
shrl $0x3, %ecx
movl %r13d, %eax
andl $0x7, %eax
movzbl (%r14,%rcx), %ecx
testl %ebx, %ebx
je 0xe4a5
shlxl %eax, %ecx, %eax
shrb $0x7, %al
movzbl %al, %edx
jmp 0xe4ad
shrxl %eax, %ecx, %edx
andl $0x1, %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5730
incl %r13d
jmp 0xe47e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x5390
movq (%r12), %rsi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5390
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs32bitWords
void displayStateAs32bitWords(int level, const char *text, const unsigned int *state)
{
    unsigned int i;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%08X:%08X", (unsigned int)state[2*i+0], (unsigned int)state[2*i+1]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
            else
                fprintf(intermediateValueFile, " ");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x6ade(%rip), %r15      # 0x14ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe590
movq 0x6ad7(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe590
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x17c2(%rip), %rsi      # 0xfcf4
xorl %eax, %eax
callq 0x5730
movb $0x4, %bpl
pushq $0xa
popq %r13
xorl %r14d, %r14d
movzbl %r14b, %eax
movb $0x5, %cl
divb %cl
cmpq $0x19, %r14
je 0xe590
movzbl %al, %eax
leal (%rax,%rax,4), %r12d
addb %bpl, %r12b
movq (%r15), %rdi
movl (%rbx,%r14,8), %edx
movl 0x4(%rbx,%r14,8), %ecx
leaq 0xd15(%rip), %rsi       # 0xf283
xorl %eax, %eax
callq 0x5730
movl %r13d, %edi
testb %r12b, %r12b
je 0xe580
pushq $0x20
popq %rdi
movq (%r15), %rsi
callq 0x5390
incq %r14
decb %bpl
jmp 0xe543
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs64bitLanes
void displayStateAs64bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned long long int *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] >> 32));
            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] & 0xFFFFFFFFULL));
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
            else
                fprintf(intermediateValueFile, " ");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x6a3d(%rip), %r15      # 0x14ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe641
movq 0x6a32(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe641
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x171d(%rip), %rsi      # 0xfcf4
xorl %eax, %eax
callq 0x5730
movb $0x4, %bpl
leaq 0xca0(%rip), %r14       # 0xf288
xorl %r12d, %r12d
movzbl %r12b, %eax
movb $0x5, %cl
divb %cl
cmpq $0x19, %r12
je 0xe641
movzbl %al, %eax
leal (%rax,%rax,4), %r13d
addb %bpl, %r13b
movq (%r15), %rdi
movl 0x4(%rbx,%r12,8), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5730
movq (%r15), %rdi
movl (%rbx,%r12,8), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5730
pushq $0xa
popq %rdi
testb %r13b, %r13b
je 0xe631
pushq $0x20
popq %rdi
movq (%r15), %rsi
callq 0x5390
incq %r12
decb %bpl
jmp 0xe5eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs32bitLanes
void displayStateAs32bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned int *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%08X", state[i]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
            else
                fprintf(intermediateValueFile, " ");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x698c(%rip), %r15      # 0x14ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe6dd
movq 0x6985(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe6dd
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x1670(%rip), %rsi      # 0xfcf4
xorl %eax, %eax
callq 0x5730
movb $0x4, %bpl
pushq $0xa
popq %r13
xorl %r14d, %r14d
movzbl %r14b, %eax
movb $0x5, %cl
divb %cl
cmpq $0x19, %r14
je 0xe6dd
movzbl %al, %eax
leal (%rax,%rax,4), %r12d
addb %bpl, %r12b
movq (%r15), %rdi
movl (%rbx,%r14,4), %edx
leaq 0xbcd(%rip), %rsi       # 0xf288
xorl %eax, %eax
callq 0x5730
movl %r13d, %edi
testb %r12b, %r12b
je 0xe6cd
pushq $0x20
popq %rdi
movq (%r15), %rsi
callq 0x5390
incq %r14
decb %bpl
jmp 0xe695
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs16bitLanes
void displayStateAs16bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned short *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%04X ", state[i]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x68f0(%rip), %r15      # 0x14ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe773
movq 0x68e9(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe773
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x15d4(%rip), %rsi      # 0xfcf4
xorl %eax, %eax
callq 0x5730
movb $0x4, %r12b
movb $0x5, %r13b
xorl %ebp, %ebp
movzbl %bpl, %eax
divb %r13b
cmpq $0x19, %rbp
je 0xe773
movzbl %al, %eax
leal (%rax,%rax,4), %r14d
addb %r12b, %r14b
movq (%r15), %rdi
movzwl (%rbx,%rbp,2), %edx
leaq 0x15af(%rip), %rsi      # 0xfd03
xorl %eax, %eax
callq 0x5730
testb %r14b, %r14b
jne 0xe76b
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x5390
incq %rbp
decb %r12b
jmp 0xe72f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayStateAs8bitLanes
void displayStateAs8bitLanes(int level, const char *text, void *statePointer)
{
    unsigned int i;
    unsigned char *state = statePointer;

    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s:\n", text);
        for(i=0; i<25; i++) {
            fprintf(intermediateValueFile, "%02X ", state[i]);
            if ((i%5) == 4)
                fprintf(intermediateValueFile, "\n");
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x685a(%rip), %r15      # 0x14ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xe80e
movq 0x6853(%rip), %rcx      # 0x14ff8
cmpl %eax, (%rcx)
jl 0xe80e
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x153e(%rip), %rsi      # 0xfcf4
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x5730
movb $0x4, %r13b
pushq $-0x19
popq %rbp
movzbl %r12b, %eax
movb $0x5, %cl
divb %cl
testq %rbp, %rbp
je 0xe80e
movzbl %al, %eax
leal (%rax,%rax,4), %r14d
addb %r13b, %r14b
movq (%r15), %rdi
movzbl 0x19(%rbx,%rbp), %edx
leaq 0x150d(%rip), %rsi      # 0xfcf9
xorl %eax, %eax
callq 0x5730
testb %r14b, %r14b
jne 0xe803
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x5390
decb %r13b
incb %r12b
incq %rbp
jmp 0xe7c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayRoundNumber
void displayRoundNumber(int level, unsigned int i)
{
    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "--- Round %d ---\n", i);
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq 0x6795(%rip), %r14      # 0x14ff0
movq (%r14), %rsi
testq %rsi, %rsi
je 0xe899
movq 0x678e(%rip), %rax      # 0x14ff8
cmpl %edi, (%rax)
jl 0xe899
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x5390
movq (%r14), %rdi
leaq 0x1487(%rip), %rsi      # 0xfd09
movl %ebx, %edx
xorl %eax, %eax
callq 0x5730
movq (%r14), %rsi
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x5390
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/displayIntermediateValues.c
// Function: displayText
void displayText(int level, const char *text)
{
    if ((intermediateValueFile) && (level <= displayLevel)) {
        fprintf(intermediateValueFile, "%s", text);
        fprintf(intermediateValueFile, "\n");
        fprintf(intermediateValueFile, "\n");
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x6747(%rip), %r14      # 0x14ff0
movq (%r14), %rax
testq %rax, %rax
je 0xe8e5
movq 0x6740(%rip), %rcx      # 0x14ff8
cmpl %edi, (%rcx)
jl 0xe8e5
movq %rsi, %rdi
movq %rax, %rsi
callq 0x54b0
movq (%r14), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x5390
movq (%r14), %rsi
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5390
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_add.c
// Function: shmem_int_atomic_add
void shmem_int_atomic_add( int* ptr, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe );
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	*remote_ptr = __sum(*remote_ptr,val);
	__clear_spin_lock(x);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edx, %esi
callq 0x1bb4
movq %rax, %r14
leaq 0x33b3(%rip), %rdi      # 0x61f0
addq $0x10, %rdi
movl %ebx, %esi
callq 0x1bb4
movq %rax, %rbx
movq %rax, %rdi
callq 0x30c8
addl %ebp, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30b8
nop
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_12/copy_io_nl.c
// Function: main
int main()
{
  int character;
  int previous_character = EOF;

  while ((character = getchar()) != EOF) {
    if (character == ' ' || character == '\t' || character == '\n') {
      if (previous_character != ' ' && previous_character != '\t' && previous_character != '\n') {
        putchar('\n');
      }
    }
    else {
      putchar(character);
    }

    previous_character = character;
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %r15
pushq $0xa
popq %rbp
movabsq $0x100000600, %r14      # imm = 0x100000600
callq 0x1040
movl %eax, %ebx
leal -0x9(%rbx), %eax
cmpl $0x2, %eax
jb 0x1181
cmpl $0x20, %ebx
je 0x1181
movl %ebx, %edi
cmpl $-0x1, %ebx
jne 0x1197
jmp 0x11a1
movl %ebp, %edi
cmpl $0x20, %r15d
ja 0x1197
movl %r15d, %eax
btq %rax, %r14
movl %ebx, %r15d
movl %ebp, %edi
jb 0x1164
callq 0x1030
movl %ebx, %r15d
jmp 0x1164
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: writerim
static  void
writerim (void)
{
    char    fname [PATH_MAX];
    char    leader [LEADER_LENGTH];
    FILE    *fp;
    int     i;

    // create the filename and open it
    sprintf (fname, "%s.rim", tapename);
    if ((fp = fopen (fname, "w")) == NULL) {
        fprintf (stderr, "%s:  unable to open RIM output file %s for w, errno %d (%s); creation of output file skipped\n", progname, fname, errno, strerror (errno));
        return;
    }

    // write leader
    memset (leader, 0x80, sizeof (leader));
    fwrite (leader, 1, sizeof (leader), fp);

    for (i = 0; i < CORE_SIZE; i++) {
        if (core [i] != -1) {
            fprintf (fp, "%c%c%c%c", 0x40 + ((i & 07700) >> 6), i & 00077, (core [i] & 07700) >> 6, core [i] & 00077);
        }
    }

    // write trailer
    fwrite (leader, 1, sizeof (leader), fp);

    fclose (fp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp           # imm = 0x1010
movq 0xcf73(%rip), %rdx      # 0x10f50
leaq 0x2974(%rip), %rsi      # 0x6958
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31a0
leaq 0x303c(%rip), %rsi      # 0x7036
movq %rbx, %rdi
callq 0x3170
testq %rax, %rax
je 0x40ac
movq %rax, %rbx
movaps 0x201b(%rip), %xmm0     # 0x6030
movq %rsp, %rdi
movaps %xmm0, (%rdi)
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
movq %rax, %rcx
callq 0x31c0
leaq 0x8f10(%rip), %r15      # 0xcf40
leaq 0x2986(%rip), %r14      # 0x69bd
xorl %r12d, %r12d
cmpq $0x1000, %r12           # imm = 0x1000
je 0x4084
movzwl (%r15), %r9d
cmpl $0xffff, %r9d           # imm = 0xFFFF
je 0x407b
movl %r12d, %edx
shrl $0x6, %edx
orl $0x40, %edx
movl %r12d, %ecx
andl $0x3f, %ecx
movl %r9d, %r8d
shrl $0x6, %r8d
andl $0x3f, %r8d
andl $0x3f, %r9d
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
incq %r12
addq $0x2, %r15
jmp 0x403a
movq %rsp, %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
movq %rbx, %rcx
callq 0x31c0
movq %rbx, %rdi
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x30a0
movq 0x7f45(%rip), %rax      # 0xbff8
movq (%rax), %rbx
movq 0x8053(%rip), %r14      # 0xc110
callq 0x3060
movl (%rax), %ebp
movl %ebp, %edi
callq 0x31d0
leaq 0x288d(%rip), %rsi      # 0x695f
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x3120
addq $0x1010, %rsp           # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: usageError
static void
usageError ()
{
    fprintf (stderr, "\nUsage:  %s [options] papertapefile [papertapefile...]\n\n", progname);
    fprintf (stderr, "where [options] are optional parameters chosen from:\n");
    fprintf (stderr, "    -b             generate a BIN-formatted output (adds \".bin\")\n");
    fprintf (stderr, "    -d             suppress disassembly (useful for conversion-only mode)\n");
    fprintf (stderr, "    -r             generate a RIM-formatted output (adds \".rim\")\n");
    fprintf (stderr, "    -v             verbose operation\n");
    fprintf (stderr, "\n");
    fprintf (stderr, "Dumps the RIM- or BIN-formatted input file(s) specified on\n");
    fprintf (stderr, "the command line.  If the \"-r\" and/or \"-b\" options are\n");
    fprintf (stderr, "present, also creates a RIM and/or BIN version of the output\n");
    fprintf (stderr, "by adding \".rim\" and/or \".bin\" (respectively) to the input\n");
    fprintf (stderr, "filename (can be used to \"clean up\" BIN and RIM images by\n");
    fprintf (stderr, "deleting excess data before and after the leader/trailer).\n");
    fprintf (stderr, "\n");
    fprintf (stderr, "Disassembly conforms to PAL III input requirements\n");
    fprintf (stderr, "\n");
    exit (EXIT_FAILURE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x7ef0(%rip), %r15      # 0xbff8
movq (%r15), %rdi
movq 0x7ffe(%rip), %rdx      # 0xc110
leaq 0x2003(%rip), %rsi      # 0x611c
xorl %eax, %eax
callq 0x3120
movq (%r15), %rcx
leaq 0x202b(%rip), %rdi      # 0x6155
pushq $0x35
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x2049(%rip), %rdi      # 0x618b
pushq $0x41
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x2072(%rip), %rdi      # 0x61cd
pushq $0x4a
popq %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x20a8(%rip), %rdi      # 0x6218
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x20d5(%rip), %rdi      # 0x625a
pushq $0x25
popq %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rsi
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x30f0
movq (%r15), %rcx
leaq 0x20d9(%rip), %rdi      # 0x6280
pushq $0x3b
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x20fc(%rip), %rdi      # 0x62bc
pushq $0x37
popq %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x211f(%rip), %rdi      # 0x62f4
pushq $0x3d
popq %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x2148(%rip), %rdi      # 0x6332
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x216f(%rip), %rdi      # 0x636e
pushq $0x3a
popq %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rcx
leaq 0x2195(%rip), %rdi      # 0x63a9
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rsi
movl %ebp, %edi
callq 0x30f0
movq (%r15), %rcx
leaq 0x21b2(%rip), %rdi      # 0x63e5
pushq $0x33
popq %rsi
movq %rbx, %rdx
callq 0x31c0
movq (%r15), %rsi
movl %ebp, %edi
callq 0x30f0
pushq $0x1
popq %rdi
callq 0x31b0
// File: /workspace/github_c_makefile_star2_O2/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: seg_more
static void
seg_more (int len)
{
    if (optv > 3) {
        printf ("seg_more (+%d (0%04o))\n", len, len);
    }

    if (nsegments) {
        segments [nsegments - 1].nwords += len;
    } else {
        fprintf (stderr, "%s:  seg_more called with no segments in existence\n", progname);
        exit (EXIT_FAILURE);
    }
}

// Assembly:
pushq %rax
cmpl $0x4, 0x8cd8(%rip)      # 0xcf30
jl 0x426d
leaq 0x2455(%rip), %rdi      # 0x66b6
pushq $0x1
popq %rdx
movl %edx, %esi
xorl %eax, %eax
callq 0x30c0
movslq 0xccd4(%rip), %rax      # 0x10f48
testq %rax, %rax
je 0x4287
movq 0xccc0(%rip), %rcx      # 0x10f40
incw -0x2(%rcx,%rax,4)
popq %rax
retq
movq 0x7d6a(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq 0x7e78(%rip), %rdx      # 0xc110
leaq 0x242f(%rip), %rsi      # 0x66ce
xorl %eax, %eax
callq 0x3120
pushq $0x1
popq %rdi
callq 0x31b0