LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/kthread.c
// Function: kt_forpool_destroy
void kt_forpool_destroy(void *_fp)
{
	kt_forpool_t *fp = (kt_forpool_t*)_fp;
	int i;
	for (i = 0; i < fp->n_threads; ++i) fp->w[i].action = -1;
	pthread_cond_broadcast(&fp->cv_s);
	for (i = 0; i < fp->n_threads; ++i) pthread_join(fp->tid[i], 0);
	pthread_cond_destroy(&fp->cv_s);
	pthread_cond_destroy(&fp->cv_m);
	pthread_mutex_destroy(&fp->mutex);
	free(fp->w); free(fp->tid); free(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x62aa
movq 0x18(%rbx), %rax
leal 0x3(%rcx), %edx
decq %rcx
movq %rcx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
shrl $0x2, %edx
shlq $0x5, %rdx
leaq (%rdx,%rdx,2), %rcx
movdqa 0x1714(%rip), %xmm1     # 0x78e0
movdqa 0x16dc(%rip), %xmm2     # 0x78b0
xorl %edx, %edx
movdqa 0x16e2(%rip), %xmm3     # 0x78c0
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movdqa 0x1702(%rip), %xmm5     # 0x78f0
movdqa %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x622b
movl $0xffffffff, 0x10(%rax,%rdx) # imm = 0xFFFFFFFF
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x6242
movl $0xffffffff, 0x28(%rax,%rdx) # imm = 0xFFFFFFFF
movdqa %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %esi
testb $0x1, %sil
je 0x6282
movl $0xffffffff, 0x40(%rax,%rdx) # imm = 0xFFFFFFFF
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x6295
movl $0xffffffff, 0x58(%rax,%rdx) # imm = 0xFFFFFFFF
paddq %xmm5, %xmm2
paddq %xmm5, %xmm1
addq $0x60, %rdx
cmpq %rdx, %rcx
jne 0x61ee
leaq 0x88(%rbx), %r14
movq %r14, %rdi
callq 0x20a0
cmpl $0x0, (%rbx)
jle 0x62db
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x23a0
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x62c1
movq %r14, %rdi
callq 0x2300
leaq 0x58(%rbx), %rdi
callq 0x2300
leaq 0x30(%rbx), %rdi
callq 0x2150
movq 0x18(%rbx), %rdi
callq 0x2050
movq 0x10(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/c-zhou[P]oatk/kthread.c
// Function: kt_forpool
void kt_forpool(void *_fp, void (*func)(void*,long,int), void *data, long n)
{
	kt_forpool_t *fp = (kt_forpool_t*)_fp;
	long i;
	if (fp && fp->n_threads > 1) {
		fp->n = n, fp->func = func, fp->data = data, fp->n_pending = fp->n_threads;
		for (i = 0; i < fp->n_threads; ++i) fp->w[i].i = i, fp->w[i].action = 1;
		pthread_mutex_lock(&fp->mutex);
		pthread_cond_broadcast(&fp->cv_s);
		while (fp->n_pending) pthread_cond_wait(&fp->cv_m, &fp->mutex);
		pthread_mutex_unlock(&fp->mutex);
	} else for (i = 0; i < n; ++i) func(data, i, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
testq %rdi, %rdi
je 0x63af
movq %rdi, %rbx
movslq (%rdi), %rax
cmpq $0x2, %rax
jl 0x63af
movq %r15, 0x8(%rbx)
movq %r12, 0x20(%rbx)
movq %r14, 0x28(%rbx)
movl %eax, 0x4(%rbx)
movq 0x18(%rbx), %rcx
addq $0x10, %rcx
xorl %edx, %edx
movq %rdx, -0x8(%rcx)
movl $0x1, (%rcx)
incq %rdx
addq $0x18, %rcx
cmpq %rdx, %rax
jne 0x6353
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x23e0
leaq 0x88(%rbx), %rdi
callq 0x20a0
cmpl $0x0, 0x4(%rbx)
je 0x639c
leaq 0x58(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2100
cmpl $0x0, 0x4(%rbx)
jne 0x638b
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2260
testq %r15, %r15
jle 0x63c9
xorl %ebx, %ebx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r12
incq %rbx
cmpq %rbx, %r15
jne 0x63b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %r14d
cmovgel %edi, %r14d
leaq -0x88(%rbp), %rdi
movl %r14d, -0x10(%rdi)
movl %ecx, -0xc(%rdi)
movq %rsi, -0x20(%rdi)
movq %rdx, -0x28(%rdi)
movq $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
movl $0x0, 0x10(%rax,%rbx)
movq %rdx, (%rax,%rbx)
movq $0x0, 0x18(%rax,%rbx)
movq %rcx, 0x8(%rax,%rbx)
incq %rcx
addq $0x20, %rbx
cmpq %rbx, %r13
jne 0x644a
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 0x65(%rip), %r15        # 0x64ff
movq %rbx, %r12
movq -0x90(%rbp), %rcx
addq %r14, %rcx
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x22e0
addq $0x20, %r14
addq $0x8, %r12
cmpq %r14, %r13
jne 0x649d
xorl %r14d, %r14d
movq -0x30(%rbp), %r15
movq (%rbx,%r14,8), %rdi
xorl %esi, %esi
callq 0x23a0
incq %r14
cmpq %r14, %r15
jne 0x64c8
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_O3/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 0x5942
leaq 0x7(%rsp), %rax
movb %sil, (%rax)
movq %rax, %rsi
movl $0x1, %ecx
callq 0x5670
popq %rax
retq
leaq 0xa703(%rip), %rdi      # 0x1004c
leaq 0xa709(%rip), %rsi      # 0x10059
leaq 0xa748(%rip), %rcx      # 0x1009f
movl $0xc4, %edx
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xc8, %edx
jae 0x59ce
movl %ecx, %ebx
movl %edx, %r14d
leal (%rbx,%r14), %eax
cmpl $0xc8, %eax
ja 0x59ed
testl %ebx, %ebx
je 0x59c4
movq %rsi, %r15
movq %rdi, %r12
movl %r14d, %ecx
andl $0x7, %ecx
shrl $0x3, %r14d
movl $0x8, %r13d
subl %ecx, %r13d
cmpl %ebx, %r13d
cmovael %ebx, %r13d
movq %r12, %rdi
movl %r14d, %esi
movq %r15, %rdx
movl %r13d, %r8d
callq 0x54a0
incl %r14d
addq %r13, %r15
xorl %ecx, %ecx
subl %r13d, %ebx
jne 0x5996
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xa677(%rip), %rdi      # 0x1004c
leaq 0xa67d(%rip), %rsi      # 0x10059
leaq 0xa6fa(%rip), %rcx      # 0x100dd
movl $0xe9, %edx
callq 0x51a0
leaq 0xa73e(%rip), %rdi      # 0x10132
leaq 0xa65e(%rip), %rsi      # 0x10059
leaq 0xa6db(%rip), %rcx      # 0x100dd
movl $0xea, %edx
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/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 0x5b05
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rsp), %rbp
movq %rbp, %rdx
xorl %ecx, %ecx
movl $0x8, %r8d
callq 0x5030
movl %r13d, %eax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
movl %r12d, %edx
movq %r15, %rsi
callq 0x5720
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_O3/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 0x5b83
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 0x5660
movq (%r12), %rax
movq %rax, 0x10(%rsp)
movl %r15d, %eax
leaq (%rsp,%rax), %rsi
addq $0x10, %rsi
movl %r14d, %edx
movq %rbx, %rdi
callq 0x5720
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xc8, %edx
jae 0x5bfc
movl %ecx, %ebx
movl %edx, %r14d
leal (%rbx,%r14), %eax
cmpl $0xc8, %eax
ja 0x5c1b
testl %ebx, %ebx
je 0x5bf2
movq %rsi, %r15
movq %rdi, %r12
movl %r14d, %ecx
andl $0x7, %ecx
shrl $0x3, %r14d
movl $0x8, %r13d
subl %ecx, %r13d
cmpl %ebx, %r13d
cmovael %ebx, %r13d
movq %r12, %rdi
movl %r14d, %esi
movq %r15, %rdx
movl %r13d, %r8d
callq 0x54f0
incl %r14d
addq %r13, %r15
xorl %ecx, %ecx
subl %r13d, %ebx
jne 0x5bc4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xa449(%rip), %rdi      # 0x1004c
leaq 0xa44f(%rip), %rsi      # 0x10059
leaq 0xa536(%rip), %rcx      # 0x10147
movl $0x119, %edx            # imm = 0x119
callq 0x51a0
leaq 0xa510(%rip), %rdi      # 0x10132
leaq 0xa430(%rip), %rsi      # 0x10059
leaq 0xa517(%rip), %rcx      # 0x10147
movl $0x11a, %edx            # imm = 0x11A
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/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 %rax
cmpl $0xc9, %esi
jae 0x5c7c
movl %esi, %r8d
movq $0x0, (%rsp)
testl %esi, %esi
je 0x5c7a
xorl %esi, %esi
movl %r8d, %eax
subl $0x8, %eax
jb 0x5c70
movq $0x0, (%rdi,%rsi,8)
incq %rsi
movl %eax, %r8d
testl %eax, %eax
jne 0x5c57
jmp 0x5c7a
movq %rsp, %rdx
xorl %ecx, %ecx
callq 0x54f0
popq %rax
retq
leaq 0xa51f(%rip), %rdi      # 0x101a2
leaq 0xa3cf(%rip), %rsi      # 0x10059
leaq 0xa522(%rip), %rcx      # 0x101b3
movl $0x12e, %edx            # imm = 0x12E
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_Permute_12rounds
void KeccakP1600_Permute_12rounds(void *state)
{
    UINT32 *stateAsHalfLanes = (UINT32*)state;
    {
        UINT8 stateAsBytes[1600/8];
        KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
#ifdef KeccakReference
        displayStateAsBytes(1, "Input of permutation", stateAsBytes, 1600);
#endif
    }
    KeccakP1600_PermutationOnWords(stateAsHalfLanes, 12);
    {
        UINT8 stateAsBytes[1600/8];
        KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
#ifdef KeccakReference
        displayStateAsBytes(1, "State after permutation", stateAsBytes, 1600);
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0xc8, %r12d
xorl %ebp, %ebp
cmpl $0x8, %r12d
movl $0x8, %r15d
cmovbl %r12d, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x5030
subl %r15d, %r12d
incl %ebp
addq %r15, %r14
cmpl $0x19, %ebp
jne 0x5cb8
movq %rbx, %rdi
movl $0xc, %esi
callq 0x55a0
movq %rsp, %r14
movl $0xc8, %r12d
xorl %ebp, %ebp
cmpl $0x8, %r12d
movl $0x8, %r15d
cmovbl %r12d, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x5030
subl %r15d, %r12d
incl %ebp
addq %r15, %r14
cmpl $0x19, %ebp
jne 0x5cfd
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0xc8, %edx
jae 0x5da7
movl %ecx, %ebx
movl %edx, %r14d
leal (%rbx,%r14), %eax
cmpl $0xc8, %eax
ja 0x5dc6
testl %ebx, %ebx
je 0x5d9d
movq %rsi, %r15
movq %rdi, %r12
movl %r14d, %ecx
andl $0x7, %ecx
shrl $0x3, %r14d
movl $0x8, %r13d
subl %ecx, %r13d
cmpl %ebx, %r13d
cmovael %ebx, %r13d
movq %r12, %rdi
movl %r14d, %esi
movq %r15, %rdx
movl %r13d, %r8d
callq 0x5030
incl %r14d
addq %r13, %r15
xorl %ecx, %ecx
subl %r13d, %ebx
jne 0x5d6f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xa29e(%rip), %rdi      # 0x1004c
leaq 0xa2a4(%rip), %rsi      # 0x10059
leaq 0xa432(%rip), %rcx      # 0x101ee
movl $0x201, %edx            # imm = 0x201
callq 0x51a0
leaq 0xa365(%rip), %rdi      # 0x10132
leaq 0xa285(%rip), %rsi      # 0x10059
leaq 0xa413(%rip), %rcx      # 0x101ee
movl $0x202, %edx            # imm = 0x202
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: KeccakP1600_Permute_24rounds
void KeccakP1600_Permute_24rounds(void *state)
{
    UINT32 *stateAsHalfLanes = (UINT32*)state;
    {
        UINT8 stateAsBytes[1600/8];
        KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
#ifdef KeccakReference
        displayStateAsBytes(1, "Input of permutation", stateAsBytes, 1600);
#endif
    }
    KeccakP1600_PermutationOnWords(stateAsHalfLanes, 24);
    {
        UINT8 stateAsBytes[1600/8];
        KeccakP1600_ExtractBytes(state, stateAsBytes, 0, 1600/8);
#ifdef KeccakReference
        displayStateAsBytes(1, "State after permutation", stateAsBytes, 1600);
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movl $0xc8, %r12d
xorl %ebp, %ebp
cmpl $0x8, %r12d
movl $0x8, %r15d
cmovbl %r12d, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x5030
subl %r15d, %r12d
incl %ebp
addq %r15, %r14
cmpl $0x19, %ebp
jne 0x61b3
movq %rbx, %rdi
movl $0x18, %esi
callq 0x55a0
movq %rsp, %r14
movl $0xc8, %r12d
xorl %ebp, %ebp
cmpl $0x8, %r12d
movl $0x8, %r15d
cmovbl %r12d, %r15d
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
movl %r15d, %r8d
callq 0x5030
subl %r15d, %r12d
incl %ebp
addq %r15, %r14
cmpl $0x19, %ebp
jne 0x61f8
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x626d
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 0x62a5
incl %eax
jne 0x627b
movl %esi, (%rdx)
movl $0xfffffffe, %r8d       # imm = 0xFFFFFFFE
jmp 0x6293
shrl %eax
shlxl %eax, %esi, %r9d
negb %al
shrxl %eax, %esi, %eax
xorl %r9d, %eax
movl %eax, (%rdx)
decl %r8d
je 0x62a5
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_O3/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 0x6304
movq %rdx, %r14
leaq 0x8(%rsp), %rdx
movl %r8d, %ecx
movl %r15d, %r8d
callq 0x5030
testl %r15d, %r15d
je 0x6304
movl %r15d, %eax
xorl %ecx, %ecx
movb 0x8(%rsp,%rcx), %dl
xorb (%r14,%rcx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x62f1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x638a
movl %r8d, %ebx
movl %ecx, %r14d
leal (%rbx,%r14), %eax
cmpl $0xc8, %eax
ja 0x63a9
testl %ebx, %ebx
je 0x637b
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl %r14d, %r8d
andl $0x7, %r8d
shrl $0x3, %r14d
movl $0x8, %ebp
subl %r8d, %ebp
cmpl %ebx, %ebp
cmovael %ebx, %ebp
movq %r13, %rdi
movl %r14d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r9d
callq 0x5220
incl %r14d
addq %rbp, %r12
addq %rbp, %r15
xorl %r8d, %r8d
subl %ebp, %ebx
jne 0x634a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9cbb(%rip), %rdi      # 0x1004c
leaq 0x9cc1(%rip), %rsi      # 0x10059
leaq 0x9ea8(%rip), %rcx      # 0x10247
movl $0x222, %edx            # imm = 0x222
callq 0x51a0
leaq 0x9d82(%rip), %rdi      # 0x10132
leaq 0x9ca2(%rip), %rsi      # 0x10059
leaq 0x9e89(%rip), %rcx      # 0x10247
movl $0x223, %edx            # imm = 0x223
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x9ee2(%rip), %r14      # 0x102bd
leaq 0x9f1e(%rip), %r13      # 0x10300
leaq 0x9ee6(%rip), %r15      # 0x102cf
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x5700
movl (%r13,%r12,8), %edx
movl 0x4(%r13,%r12,8), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5700
movl $0xa, %edi
movq %rbx, %rsi
callq 0x5370
incq %r12
cmpq $0x18, %r12
jne 0x63ec
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5370
// File: /workspace/github_c_makefile_star2_O3/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 0x9f6c(%rip), %rbp      # 0x103c0
leaq 0x9e7e(%rip), %r14      # 0x102d9
leaq 0x9e8c(%rip), %r15      # 0x102ee
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x5700
movl (%rbp,%r13,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5700
movl $0xa, %edi
movq %rbx, %rsi
callq 0x5370
incq %r13
cmpq $0x5, %r13
jne 0x6468
incq %r12
addq $0x14, %rbp
cmpq $0x5, %r12
jne 0x6465
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5370
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x7777
leal (%rcx,%rdx), %eax
cmpl $0x64, %eax
ja 0x7796
testl %ecx, %ecx
je 0x7775
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
cmpq %rdx, %rax
jne 0x7761
popq %rax
retq
leaq 0x94e6(%rip), %rdi      # 0x10c64
leaq 0x94ec(%rip), %rsi      # 0x10c71
leaq 0x9563(%rip), %rcx      # 0x10cef
movl $0x98, %edx
callq 0x51a0
leaq 0x95a6(%rip), %rdi      # 0x10d43
leaq 0x94cd(%rip), %rsi      # 0x10c71
leaq 0x9544(%rip), %rcx      # 0x10cef
movl $0x99, %edx
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/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 0x7d12
leal (%r8,%rcx), %eax
cmpl $0x64, %eax
ja 0x7d31
testl %r8d, %r8d
je 0x7d10
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
cmpq %r8, %rax
jne 0x7cf8
popq %rax
retq
leaq 0x8f4b(%rip), %rdi      # 0x10c64
leaq 0x8f51(%rip), %rsi      # 0x10c71
leaq 0x912e(%rip), %rcx      # 0x10e55
movl $0x16c, %edx            # imm = 0x16C
callq 0x51a0
leaq 0x900b(%rip), %rdi      # 0x10d43
leaq 0x8f32(%rip), %rsi      # 0x10c71
leaq 0x910f(%rip), %rcx      # 0x10e55
movl $0x16d, %edx            # imm = 0x16D
callq 0x51a0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8e3d(%rip), %r13      # 0x10ba0
leaq 0x8553(%rip), %r14      # 0x102bd
leaq 0x8563(%rip), %r15      # 0x102d4
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x5700
movl (%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5700
movl $0xa, %edi
movq %rbx, %rsi
callq 0x5370
incq %r12
addq $0x4, %r13
cmpq $0x16, %r12
jne 0x7d74
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5370
// File: /workspace/github_c_makefile_star2_O3/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 0x75c3(%rip), %r15      # 0x15ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xeaa9
movl %ecx, %ebp
movq 0x75ba(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xeaa9
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x247b(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
testl %ebp, %ebp
je 0xea81
movl %ebp, %r12d
leaq 0x246b(%rip), %r14      # 0x10ecf
xorl %r13d, %r13d
movq (%r15), %rdi
movzbl (%rbx,%r13), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5700
incq %r13
cmpq %r13, %r12
jne 0xea67
movq (%r15), %rsi
movl $0xa, %edi
callq 0x5370
movq (%r15), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7524(%rip), %r12      # 0x15ff0
movq (%r12), %rdi
testq %rdi, %rdi
je 0xeb79
movl %ecx, %ebp
movq 0x7516(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xeb79
movl %r8d, %ebx
movq %rdx, %r14
movq %rsi, %rdx
leaq 0x23d0(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
testl %ebp, %ebp
je 0xeb4f
leaq 0x23c9(%rip), %r15      # 0x10ed5
xorl %r13d, %r13d
movl %r13d, %ecx
shrl $0x3, %ecx
movl %r13d, %eax
andl $0x7, %eax
movzbl (%r14,%rcx), %ecx
testl %ebx, %ebx
je 0xeb31
shlxl %eax, %ecx, %eax
shrb $0x7, %al
movzbl %al, %edx
jmp 0xeb39
shrxl %eax, %ecx, %edx
andl $0x1, %edx
movq (%r12), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x5700
incl %r13d
cmpl %r13d, %ebp
jne 0xeb0f
movq (%r12), %rsi
movl $0xa, %edi
callq 0x5370
movq (%r12), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5370
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x744c(%rip), %r15      # 0x15ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xec22
movq 0x7445(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xec22
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x2306(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
movb $0x4, %bpl
movl $0xa, %r12d
xorl %r13d, %r13d
movzbl %r13b, %eax
imull $0xcd, %eax, %eax
shrl $0xa, %eax
leal (%rax,%rax,4), %r14d
movq (%r15), %rdi
movl (%rbx,%r13,8), %edx
movl 0x4(%rbx,%r13,8), %ecx
leaq 0x16d4(%rip), %rsi      # 0x102cf
xorl %eax, %eax
callq 0x5700
addb %bpl, %r14b
movq (%r15), %rsi
movl $0x20, %edi
cmovel %r12d, %edi
callq 0x5370
incq %r13
decb %bpl
cmpq $0x19, %r13
jne 0xebd7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x73ab(%rip), %r15      # 0x15ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xecd5
movq 0x73a0(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xecd5
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x2261(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
movb $0x4, %bpl
leaq 0x165a(%rip), %r14      # 0x102d4
xorl %r13d, %r13d
movzbl %r13b, %eax
imull $0xcd, %eax, %eax
shrl $0xa, %eax
leal (%rax,%rax,4), %r12d
movq (%r15), %rdi
movl 0x4(%rbx,%r13,8), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5700
movq (%r15), %rdi
movl (%rbx,%r13,8), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5700
addb %bpl, %r12b
movq (%r15), %rsi
movl $0x20, %edi
movl $0xa, %eax
cmovel %eax, %edi
callq 0x5370
incq %r13
decb %bpl
cmpq $0x19, %r13
jne 0xec7d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x72f8(%rip), %r15      # 0x15ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xed71
movq 0x72f1(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xed71
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x21b2(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
movb $0x4, %bpl
movl $0xa, %r12d
xorl %r13d, %r13d
movzbl %r13b, %eax
imull $0xcd, %eax, %eax
shrl $0xa, %eax
leal (%rax,%rax,4), %r14d
movq (%r15), %rdi
movl (%rbx,%r13,4), %edx
leaq 0x158a(%rip), %rsi      # 0x102d4
xorl %eax, %eax
callq 0x5700
addb %bpl, %r14b
movq (%r15), %rsi
movl $0x20, %edi
cmovel %r12d, %edi
callq 0x5370
incq %r13
decb %bpl
cmpq $0x19, %r13
jne 0xed2b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x725c(%rip), %r15      # 0x15ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xee09
movq 0x7255(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xee09
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x2116(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
movb $0x4, %bpl
leaq 0x2114(%rip), %r14      # 0x10ed9
xorl %r12d, %r12d
movzbl %r12b, %eax
imull $0xcd, %eax, %eax
shrl $0xa, %eax
leal (%rax,%rax,4), %r13d
movq (%r15), %rdi
movzwl (%rbx,%r12,2), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5700
addb %bpl, %r13b
jne 0xedfd
movq (%r15), %rsi
movl $0xa, %edi
callq 0x5370
incq %r12
decb %bpl
cmpq $0x19, %r12
jne 0xedc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x71c4(%rip), %r15      # 0x15ff0
movq (%r15), %rdi
testq %rdi, %rdi
je 0xeea1
movq 0x71bd(%rip), %rcx      # 0x15ff8
cmpl %eax, (%rcx)
jl 0xeea1
movq %rdx, %rbx
movq %rsi, %rdx
leaq 0x207e(%rip), %rsi      # 0x10eca
xorl %eax, %eax
callq 0x5700
movb $0x4, %bpl
leaq 0x2072(%rip), %r14      # 0x10ecf
xorl %r12d, %r12d
movzbl %r12b, %eax
imull $0xcd, %eax, %eax
shrl $0xa, %eax
leal (%rax,%rax,4), %r13d
movq (%r15), %rdi
movzbl (%rbx,%r12), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x5700
addb %bpl, %r13b
jne 0xee95
movq (%r15), %rsi
movl $0xa, %edi
callq 0x5370
incq %r12
decb %bpl
cmpq $0x19, %r12
jne 0xee60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x70f8(%rip), %r14      # 0x15ff0
movq (%r14), %rsi
testq %rsi, %rsi
je 0xef3c
movq 0x70f1(%rip), %rax      # 0x15ff8
cmpl %edi, (%rax)
jl 0xef3c
movl $0xa, %edi
callq 0x5370
movq (%r14), %rdi
leaq 0x1fc0(%rip), %rsi      # 0x10edf
movl %ebx, %edx
xorl %eax, %eax
callq 0x5700
movq (%r14), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5370
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x70a4(%rip), %rbx      # 0x15ff0
movq (%rbx), %rax
testq %rax, %rax
je 0xef85
movq 0x709d(%rip), %rcx      # 0x15ff8
cmpl %edi, (%rcx)
jl 0xef85
movq %rsi, %rdi
movq %rax, %rsi
callq 0x5490
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x5370
movq (%rbx), %rsi
movl $0xa, %edi
popq %rbx
jmp 0x5370
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x1c58
movq %rax, %r14
leaq 0x3197(%rip), %rdi      # 0x61f0
addq $0x10, %rdi
movl %ebx, %esi
callq 0x1c58
movq %rax, %rbx
movq %rax, %rdi
callq 0x331f
addl %ebp, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3310
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq 0xcd54(%rip), %rdx      # 0x10f50
leaq 0x2795(%rip), %rsi      # 0x6998
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31a0
leaq 0x2e5d(%rip), %rsi      # 0x7076
movq %rbx, %rdi
callq 0x3170
testq %rax, %rax
je 0x42d0
movq %rax, %rbx
movaps 0x1e1c(%rip), %xmm0     # 0x6050
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movl $0x1, %esi
movl $0x10, %edx
movq %rax, %rcx
callq 0x31c0
leaq 0x8ced(%rip), %r15      # 0xcf40
leaq 0x27a3(%rip), %r14      # 0x69fd
xorl %r12d, %r12d
movzwl (%r15), %r9d
cmpl $0xffff, %r9d           # imm = 0xFFFF
je 0x4295
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
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x425d
movq %rsp, %rdi
movl $0x1, %esi
movl $0x10, %edx
movq %rbx, %rcx
callq 0x31c0
movq %rbx, %rdi
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30a0
leaq 0x10(%rsp), %rdi
callq 0x3457
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x7d07(%rip), %rbx      # 0xbff8
movq (%rbx), %rdi
movq 0x7e15(%rip), %rdx      # 0xc110
leaq 0x1e5a(%rip), %rsi      # 0x615c
xorl %eax, %eax
callq 0x3120
movq (%rbx), %rcx
leaq 0x1e82(%rip), %rdi      # 0x6195
movl $0x35, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1e9f(%rip), %rdi      # 0x61cb
movl $0x41, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1ec8(%rip), %rdi      # 0x620d
movl $0x4a, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1efa(%rip), %rdi      # 0x6258
movl $0x41, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1f23(%rip), %rdi      # 0x629a
movl $0x25, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x30f0
movq (%rbx), %rcx
leaq 0x1f23(%rip), %rdi      # 0x62c0
movl $0x3b, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1f46(%rip), %rdi      # 0x62fc
movl $0x37, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1f65(%rip), %rdi      # 0x6334
movl $0x3d, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1f8a(%rip), %rdi      # 0x6372
movl $0x3b, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1fad(%rip), %rdi      # 0x63ae
movl $0x3a, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rcx
leaq 0x1fcf(%rip), %rdi      # 0x63e9
movl $0x3b, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x30f0
movq (%rbx), %rcx
leaq 0x1fe5(%rip), %rdi      # 0x6425
movl $0x33, %esi
movl $0x1, %edx
callq 0x31c0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x30f0
movl $0x1, %edi
callq 0x31b0