LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: check_executable
void check_executable(char *exe)
{
    char cmd[4096];
    sprintf(cmd, "command -v %s 1>/dev/null 2>/dev/null", exe);

    int exit_code = run_system_cmd(cmd, 1);
    if (exit_code == -1 || WEXITSTATUS(exit_code)) {
        fprintf(stderr, "[E::%s] executable %s is not available\n", __func__, exe);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x28aa(%rip), %rsi      # 0x972b
movb $0x0, %al
callq 0x2360
leaq -0x1010(%rbp), %rdi
movl $0x1, %esi
callq 0x6e00
movl %eax, -0x1014(%rbp)
cmpl $-0x1, -0x1014(%rbp)
je 0x6ebb
movl -0x1014(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x6ee8
movq 0x5136(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x2881(%rip), %rsi      # 0x9751
leaq 0x28a2(%rip), %rdx      # 0x9779
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2370
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: is_file
int is_file(const char *path) {
    struct stat path_stat;
    if (stat(path, &path_stat) == -1)
        return 0;  // stat error

    return S_ISREG(path_stat.st_mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2230
cmpl $-0x1, %eax
jne 0x6f2d
movl $0x0, -0x4(%rbp)
jmp 0x6f48
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: is_dir
int is_dir(const char *path) {
    struct stat path_stat;
    if (stat(path, &path_stat) == -1)
        return 0;  // stat error

    return S_ISDIR(path_stat.st_mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2230
cmpl $-0x1, %eax
jne 0x6f8d
movl $0x0, -0x4(%rbp)
jmp 0x6fa8
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: is_fifo
int is_fifo(const char *path) {
    if (*path == '-')
        return 1;

    struct stat path_stat;
    if (stat(path, &path_stat) == -1)
        return 0;  // stat error

    return S_ISFIFO(path_stat.st_mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x6fe4
movl $0x1, -0x4(%rbp)
jmp 0x701d
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2230
cmpl $-0x1, %eax
jne 0x7002
movl $0x0, -0x4(%rbp)
jmp 0x701d
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/misc.c
// Function: open_outstream
FILE *open_outstream(char *prefix, char *suffix)
{
    FILE *fo;
    char *out;

    MYMALLOC(out, strlen(prefix) + strlen(suffix) + 1);
    sprintf(out, "%s%s", prefix, suffix);
    fo = fopen(out, "w");
    if (!fo) {
        fprintf(stderr, "[E::%s] failed to open file '%s' to write: %s\n", __func__, out, strerror(errno));
        exit(EXIT_FAILURE);
    }
    free(out);

    return fo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2130
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2130
movq -0x28(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x2280
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x2709(%rip), %rsi      # 0x978a
movb $0x0, %al
callq 0x2360
movq -0x20(%rbp), %rdi
leaq 0x22b8(%rip), %rsi      # 0x934b
callq 0x2310
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x70ef
movq 0x4f4e(%rip), %rax      # 0xbff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2070
movl (%rax), %edi
callq 0x23b0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq %rax, %r8
leaq 0x26b8(%rip), %rsi      # 0x978f
leaq 0x26e0(%rip), %rdx      # 0x97be
movb $0x0, %al
callq 0x2220
movl $0x1, %edi
callq 0x2370
movq -0x20(%rbp), %rdi
callq 0x2050
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/kthread.c
// Function: kt_forpool_init
void *kt_forpool_init(int n_threads)
{
	kt_forpool_t *fp;
	int i;
	fp = (kt_forpool_t*)calloc(1, sizeof(kt_forpool_t));
	fp->n_threads = fp->n_pending = n_threads;
	fp->tid = (pthread_t*)calloc(fp->n_threads, sizeof(pthread_t));
	fp->w = (kto_worker_t*)calloc(fp->n_threads, sizeof(kto_worker_t));
	for (i = 0; i < fp->n_threads; ++i) fp->w[i].t = fp;
	pthread_mutex_init(&fp->mutex, 0);
	pthread_cond_init(&fp->cv_m, 0);
	pthread_cond_init(&fp->cv_s, 0);
	for (i = 0; i < fp->n_threads; ++i) pthread_create(&fp->tid[i], 0, kt_fp_worker, &fp->w[i]);
	pthread_mutex_lock(&fp->mutex);
	while (fp->n_pending) pthread_cond_wait(&fp->cv_m, &fp->mutex);
	pthread_mutex_unlock(&fp->mutex);
	return fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0xb8, %esi
callq 0x21f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rdi
movl $0x8, %esi
callq 0x21f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movslq (%rax), %rdi
movl $0x18, %esi
callq 0x21f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x7fad
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7f7d
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x23c0
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2250
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2250
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8036
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x5a(%rip), %rdx        # 0x8080
callq 0x22e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7fea
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x23d0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x8064
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x2100
jmp 0x8043
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2260
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/kthread.c
// Function: kt_fp_worker
static void *kt_fp_worker(void *data)
{
	kto_worker_t *w = (kto_worker_t*)data;
	kt_forpool_t *fp = w->t;
	for (;;) {
		long i;
		int action;
		pthread_mutex_lock(&fp->mutex);
		if (--fp->n_pending == 0)
			pthread_cond_signal(&fp->cv_m);
		w->action = 0;
		while (w->action == 0) pthread_cond_wait(&fp->cv_s, &fp->mutex);
		action = w->action;
		pthread_mutex_unlock(&fp->mutex);
		if (action < 0) break;
		for (;;) { // process jobs allocated to this worker
			i = __sync_fetch_and_add(&w->i, fp->n_threads);
			if (i >= fp->n) break;
			fp->func(fp->data, i, w - fp->w);
		}
		while ((i = kt_fp_steal_work(fp)) >= 0) // steal jobs allocated to other workers
			fp->func(fp->data, i, w - fp->w);
	}
	pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x23d0
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rcx)
cmpl $0x0, %eax
jne 0x80cb
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x21e0
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x80fa
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
callq 0x2100
jmp 0x80d6
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x2260
cmpl $0x0, -0x24(%rbp)
jge 0x811c
jmp 0x81d9
jmp 0x811e
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq (%rax), %rax
lock
xaddq %rax, 0x8(%rcx)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x8143
jmp 0x8181
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl %ecx, %edx
callq *%rax
jmp 0x811e
jmp 0x8183
movq -0x18(%rbp), %rdi
callq 0x8910
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jl 0x81d4
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl %ecx, %edx
callq *%rax
jmp 0x8183
jmp 0x809f
xorl %eax, %eax
movl %eax, %edi
callq 0x2270
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x823b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x820b
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x20a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8281
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2390
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8252
movq -0x10(%rbp), %rdi
addq $0x88, %rdi
callq 0x2300
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
callq 0x2300
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2160
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2050
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2050
movq -0x10(%rbp), %rdi
callq 0x2050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x83eb
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jle 0x83eb
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
cmpq %rcx, %rax
jge 0x839e
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x30(%rbp), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x30(%rbp), %rcx
addq %rcx, %rax
movl $0x1, 0x10(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x8351
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x23d0
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0x20a0
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x83dc
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq -0x28(%rbp), %rsi
addq $0x30, %rsi
callq 0x2100
jmp 0x83bb
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x2260
jmp 0x841d
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x841b
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x83f3
jmp 0x841d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x1, -0x4(%rbp)
jge 0x8456
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq $0x0, -0x90(%rbp)
leaq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xc0(%rbp)
callq 0x23c0
movq -0xc0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2250
movslq -0x4(%rbp), %rcx
shlq $0x5, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x80(%rbp)
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x8552
movq -0x80(%rbp), %rax
movslq -0xac(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0xb8(%rbp), %rax
leaq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movq -0xb8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x90(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0xb8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x84cc
movslq -0x4(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0xa8(%rbp)
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x85cf
movq -0xa8(%rbp), %rdi
movslq -0xac(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x80(%rbp), %rcx
movslq -0xac(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x87(%rip), %rdx        # 0x8640
callq 0x22e0
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x857c
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x8610
movq -0xa8(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2390
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x85d9
leaq -0xa0(%rbp), %rdi
addq $0x28, %rdi
callq 0x2160
leaq -0xa0(%rbp), %rdi
addq $0x50, %rdi
callq 0x2300
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/kthread.c
// Function: kt_fp_steal_work
static inline long kt_fp_steal_work(kt_forpool_t *t)
{
	int i, min_i = -1;
	long k, min = LONG_MAX;
	for (i = 0; i < t->n_threads; ++i)
		if (min > t->w[i].i) min = t->w[i].i, min_i = i;
	k = __sync_fetch_and_add(&t->w[min_i].i, t->n_threads);
	return k >= t->n? -1 : k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x898a
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jle 0x897d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x897f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8934
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x10(%rbp), %rdx
leaq (%rdx,%rdx,2), %rdx
movslq (%rax), %rax
lock
xaddq %rax, 0x8(%rcx,%rdx,8)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x89c3
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x89cb
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl $0x0, (%rax)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c(%rsp)
cmpl $0x40, -0x1c(%rsp)
jae 0x5926
cmpl $0x20, -0x1c(%rsp)
jae 0x58c1
movl -0x4(%rsp), %eax
movl -0x1c(%rsp), %ecx
shrl %cl, %eax
andl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x58d5
movl -0x8(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x20, %ecx
shrl %cl, %eax
andl $0x1, %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x58fa
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
shrl %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x5914
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
shrl %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x5916
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x58a0
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl $0x0, (%rax)
movq -0x18(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, -0x1c(%rsp)
cmpl $0x40, -0x1c(%rsp)
jae 0x59e6
movl -0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x5988
movl -0x4(%rsp), %eax
movl -0x1c(%rsp), %ecx
shrl %ecx
shrl %cl, %eax
andl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x599e
movl -0x8(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
shrl %ecx
shrl %cl, %eax
andl $0x1, %eax
movl %eax, -0x20(%rsp)
cmpl $0x20, -0x1c(%rsp)
jae 0x59bc
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x10(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x59d4
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x20, %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x59d6
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x5960
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl 0x14(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x8(%rsp)
cmpl $0xc8, 0x14(%rsp)
jae 0x5ab8
jmp 0x5ad7
leaq 0x11541(%rip), %rdi     # 0x17000
leaq 0x11547(%rip), %rsi     # 0x1700d
movl $0xe9, %edx
leaq 0x115bf(%rip), %rcx     # 0x17091
callq 0x51b0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0xc8, %eax
ja 0x5ae8
jmp 0x5b07
leaq 0x115f7(%rip), %rdi     # 0x170e6
leaq 0x11517(%rip), %rsi     # 0x1700d
movl $0xea, %edx
leaq 0x1158f(%rip), %rcx     # 0x17091
callq 0x51b0
jmp 0x5b09
cmpl $0x0, 0x10(%rsp)
jbe 0x5b81
movl $0x8, %eax
subl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
jbe 0x5b2f
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
callq 0x54a0
movl 0x4(%rsp), %ecx
movl 0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x5b09
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
cmpl $0x19, 0x3c(%rsp)
jae 0x5ca6
cmpl $0x8, 0x2c(%rsp)
jae 0x5ca6
movl 0x2c(%rsp), %eax
addl 0x28(%rsp), %eax
cmpl $0x8, %eax
ja 0x5ca6
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x5090
leaq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movl 0x28(%rsp), %eax
movl %eax, %edx
callq 0x5730
movzbl 0x20(%rsp), %eax
movzbl 0x21(%rsp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl 0x22(%rsp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl 0x23(%rsp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, 0x1c(%rsp)
movzbl 0x24(%rsp), %eax
movzbl 0x25(%rsp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl 0x26(%rsp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl 0x27(%rsp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
leaq 0x10(%rsp), %rdx
leaq 0x10(%rsp), %rcx
addq $0x4, %rcx
callq 0x5080
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x3c(%rsp), %ecx
shll %ecx
addl $0x0, %ecx
movl %ecx, %ecx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x3c(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl %r8d, 0x28(%rsp)
cmpl $0x19, 0x3c(%rsp)
jae 0x5dca
cmpl $0x8, 0x2c(%rsp)
jae 0x5dca
movl 0x2c(%rsp), %eax
addl 0x28(%rsp), %eax
cmpl $0x8, %eax
ja 0x5dca
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
leaq 0x20(%rsp), %rdx
xorl %ecx, %ecx
movl $0x8, %r8d
callq 0x5030
leaq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %eax
addq %rax, %rdi
movq 0x30(%rsp), %rsi
movl 0x28(%rsp), %eax
movl %eax, %edx
callq 0x5730
movzbl 0x20(%rsp), %eax
movzbl 0x21(%rsp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl 0x22(%rsp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl 0x23(%rsp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, 0x1c(%rsp)
movzbl 0x24(%rsp), %eax
movzbl 0x25(%rsp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl 0x26(%rsp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movzbl 0x27(%rsp), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
leaq 0x10(%rsp), %rdx
leaq 0x10(%rsp), %rcx
addq $0x4, %rcx
callq 0x5080
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x10(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x3c(%rsp), %ecx
shll %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x3c(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
cmpl $0x19, 0x2c(%rsp)
jae 0x5ee5
cmpl $0x8, 0x1c(%rsp)
jae 0x5ee5
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
cmpl $0x8, %eax
ja 0x5ee5
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edi
movq 0x10(%rsp), %rax
movl 0x2c(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
leaq 0x8(%rsp), %rdx
leaq 0x8(%rsp), %rcx
addq $0x4, %rcx
callq 0x5670
movl 0x8(%rsp), %eax
andl $0xff, %eax
movb %al, (%rsp)
movl 0x8(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, 0x1(%rsp)
movl 0x8(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, 0x2(%rsp)
movl 0x8(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, 0x3(%rsp)
movl 0xc(%rsp), %eax
andl $0xff, %eax
movb %al, 0x4(%rsp)
movl 0xc(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, 0x5(%rsp)
movl 0xc(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, 0x6(%rsp)
movl 0xc(%rsp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl 0x1c(%rsp), %eax
addq %rax, %rsi
movl 0x18(%rsp), %eax
movl %eax, %edx
callq 0x5730
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl 0x14(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x8(%rsp)
cmpl $0xc8, 0x14(%rsp)
jae 0x5f28
jmp 0x5f47
leaq 0x110d1(%rip), %rdi     # 0x17000
leaq 0x110d7(%rip), %rsi     # 0x1700d
movl $0x119, %edx            # imm = 0x119
leaq 0x111b9(%rip), %rcx     # 0x170fb
callq 0x51b0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0xc8, %eax
ja 0x5f58
jmp 0x5f77
leaq 0x11187(%rip), %rdi     # 0x170e6
leaq 0x110a7(%rip), %rsi     # 0x1700d
movl $0x11a, %edx            # imm = 0x11A
leaq 0x11189(%rip), %rcx     # 0x170fb
callq 0x51b0
jmp 0x5f79
cmpl $0x0, 0x10(%rsp)
jbe 0x5ff1
movl $0x8, %eax
subl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
jbe 0x5f9f
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
callq 0x54f0
movl 0x4(%rsp), %ecx
movl 0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x5f79
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x10(%rsp)
cmpl $0xc8, 0x1c(%rsp)
ja 0x6021
jmp 0x6040
leaq 0x1112e(%rip), %rdi     # 0x17156
leaq 0x10fde(%rip), %rsi     # 0x1700d
movl $0x12e, %edx            # imm = 0x12E
leaq 0x1112c(%rip), %rcx     # 0x17167
callq 0x51b0
leaq 0x14(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x5090
cmpl $0x0, 0x1c(%rsp)
jbe 0x60d6
cmpl $0x8, 0x1c(%rsp)
jae 0x6083
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %esi
leaq 0x14(%rsp), %rdx
movl 0x1c(%rsp), %r8d
xorl %ecx, %ecx
callq 0x54f0
movl $0x0, 0x1c(%rsp)
jmp 0x60d1
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
shll %ecx
addl $0x0, %ecx
movl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
shll %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movl $0x0, (%rax,%rcx,4)
movl 0x1c(%rsp), %eax
subl $0x8, %eax
movl %eax, 0x1c(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x6051
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x1a0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
xorl %edx, %edx
movl $0xc8, %ecx
callq 0x50a0
movq 0x198(%rsp), %rdi
movl $0xc, %esi
callq 0x55a0
movq 0x1a0(%rsp), %rdi
movq %rsp, %rsi
xorl %edx, %edx
movl $0xc8, %ecx
callq 0x50a0
addq $0x1a8, %rsp            # imm = 0x1A8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl 0x14(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x8(%rsp)
cmpl $0xc8, 0x14(%rsp)
jae 0x6188
jmp 0x61a7
leaq 0x10e71(%rip), %rdi     # 0x17000
leaq 0x10e77(%rip), %rsi     # 0x1700d
movl $0x201, %edx            # imm = 0x201
leaq 0x11000(%rip), %rcx     # 0x171a2
callq 0x51b0
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0xc8, %eax
ja 0x61b8
jmp 0x61d7
leaq 0x10f27(%rip), %rdi     # 0x170e6
leaq 0x10e47(%rip), %rsi     # 0x1700d
movl $0x202, %edx            # imm = 0x202
leaq 0x10fd0(%rip), %rcx     # 0x171a2
callq 0x51b0
jmp 0x61d9
cmpl $0x0, 0x10(%rsp)
jbe 0x6251
movl $0x8, %eax
subl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
jbe 0x61ff
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
callq 0x5030
movl 0x4(%rsp), %ecx
movl 0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x61d9
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: pi
static void pi(UINT32 *A)
{
    unsigned int x, y, z;
    UINT32 tempA[50];

    for(x=0; x<5; x++) for(y=0; y<5; y++) for(z=0; z<2; z++)
        tempA[index(x, y, z)] = A[index(x, y, z)];
    for(x=0; x<5; x++) for(y=0; y<5; y++) for(z=0; z<2; z++)
        A[index(0*x+1*y, 2*x+3*y, z)] = tempA[index(x, y, z)];
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl $0x0, 0x8c(%rsp)
cmpl $0x5, 0x8c(%rsp)
jae 0x6933
movl $0x0, 0x88(%rsp)
cmpl $0x5, 0x88(%rsp)
jae 0x691b
movl $0x0, 0x84(%rsp)
cmpl $0x2, 0x84(%rsp)
jae 0x6903
movq 0x90(%rsp), %rax
movq %rax, -0x60(%rsp)
movl 0x8c(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl 0x88(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x60(%rsp), %rax
imull $0x5, %edx, %edx
addl %edx, %ecx
shll %ecx
addl 0x84(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %ecx
movl 0x8c(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movl %edx, -0x54(%rsp)
movl 0x88(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movl -0x54(%rsp), %eax
imull $0x5, %edx, %edx
addl %edx, %eax
shll %eax
addl 0x84(%rsp), %eax
movl %eax, %eax
movl %ecx, -0x50(%rsp,%rax,4)
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x685c
jmp 0x6905
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x6843
jmp 0x691d
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x682a
movl $0x0, 0x8c(%rsp)
cmpl $0x5, 0x8c(%rsp)
jae 0x6a6a
movl $0x0, 0x88(%rsp)
cmpl $0x5, 0x88(%rsp)
jae 0x6a52
movl $0x0, 0x84(%rsp)
cmpl $0x2, 0x84(%rsp)
jae 0x6a3a
movl 0x8c(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x74(%rsp)
movl 0x88(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl -0x74(%rsp), %eax
imull $0x5, %edx, %ecx
addl %ecx, %eax
shll %eax
addl 0x84(%rsp), %eax
movl %eax, %eax
movl -0x50(%rsp,%rax,4), %eax
movl %eax, -0x64(%rsp)
movq 0x90(%rsp), %rax
movq %rax, -0x70(%rsp)
imull $0x0, 0x8c(%rsp), %eax
movl 0x88(%rsp), %ecx
shll $0x0, %ecx
addl %ecx, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl 0x8c(%rsp), %eax
shll %eax
imull $0x3, 0x88(%rsp), %edx
addl %edx, %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x70(%rsp), %rax
movl %edx, %esi
movl -0x64(%rsp), %edx
imull $0x5, %esi, %esi
addl %esi, %ecx
shll %ecx
addl 0x84(%rsp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x6970
jmp 0x6a3c
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x6957
jmp 0x6a54
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x693e
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference32bits/KeccakP-1600-reference32BI.c
// Function: chi
static void chi(UINT32 *A)
{
    unsigned int x, y, z;
    UINT32 C[5][2];

    for(y=0; y<5; y++) {
        for(x=0; x<5; x++)
            for(z=0; z<2; z++)
                C[x][z] = A[index(x, y, z)] ^ ((~A[index(x+1, y, z)]) & A[index(x+2, y, z)]);
        for(x=0; x<5; x++)
            for(z=0; z<2; z++)
                A[index(x, y, z)] = C[x][z];
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x5, -0x10(%rsp)
jae 0x6c6e
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0x6bbd
movl $0x0, -0x14(%rsp)
cmpl $0x2, -0x14(%rsp)
jae 0x6bab
movq -0x8(%rsp), %rax
movq %rax, -0x60(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl -0x10(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x60(%rsp), %rax
imull $0x5, %edx, %edx
addl %edx, %ecx
shll %ecx
addl -0x14(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x58(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl -0x10(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x58(%rsp), %rax
imull $0x5, %edx, %edx
addl %edx, %ecx
shll %ecx
addl -0x14(%rsp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
xorl $-0x1, %eax
movl %eax, -0x50(%rsp)
movq -0x8(%rsp), %rcx
movl -0xc(%rsp), %eax
addl $0x2, %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movl %edx, %esi
movl -0x10(%rsp), %eax
movl $0x5, %edi
xorl %edx, %edx
divl %edi
movl -0x50(%rsp), %eax
movl %edx, %edi
movl -0x4c(%rsp), %edx
imull $0x5, %edi, %edi
addl %edi, %esi
shll %esi
addl -0x14(%rsp), %esi
movl %esi, %esi
andl (%rcx,%rsi,4), %eax
xorl %eax, %edx
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq -0x48(%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movl -0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x6ab3
jmp 0x6bad
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x6aa0
movl $0x0, -0xc(%rsp)
cmpl $0x5, -0xc(%rsp)
jae 0x6c5c
movl $0x0, -0x14(%rsp)
cmpl $0x2, -0x14(%rsp)
jae 0x6c4a
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq -0x48(%rsp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movl -0x14(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x64(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x70(%rsp)
movl -0xc(%rsp), %eax
movl $0x5, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl -0x10(%rsp), %eax
movl $0x5, %esi
xorl %edx, %edx
divl %esi
movq -0x70(%rsp), %rax
movl %edx, %esi
movl -0x64(%rsp), %edx
imull $0x5, %esi, %esi
addl %esi, %ecx
shll %ecx
addl -0x14(%rsp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x6bd8
jmp 0x6c4c
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x6bc5
jmp 0x6c5e
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x6a8d
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x6d6a
movl -0x1c(%rsp), %eax
shrl %eax
cmpl $0x0, %eax
je 0x6d0b
movl -0x4(%rsp), %eax
movl -0x1c(%rsp), %ecx
shrl %ecx
shll %cl, %eax
movl -0x4(%rsp), %edx
movl -0x1c(%rsp), %esi
shrl %esi
movl $0x20, %ecx
subl %esi, %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x20(%rsp)
jmp 0x6d13
movl -0x4(%rsp), %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x1c(%rsp), %eax
shrl %eax
cmpl $0x0, %eax
je 0x6d52
movl -0x8(%rsp), %eax
movl -0x1c(%rsp), %ecx
shrl %ecx
shll %cl, %eax
movl -0x8(%rsp), %edx
movl -0x1c(%rsp), %esi
shrl %esi
movl $0x20, %ecx
subl %esi, %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x24(%rsp)
jmp 0x6d5a
movl -0x8(%rsp), %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x6e0a
movl -0x1c(%rsp), %eax
addl $0x1, %eax
shrl %eax
cmpl $0x0, %eax
je 0x6da7
movl -0x8(%rsp), %eax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
shrl %ecx
shll %cl, %eax
movl -0x8(%rsp), %edx
movl -0x1c(%rsp), %esi
addl $0x1, %esi
shrl %esi
movl $0x20, %ecx
subl %esi, %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x28(%rsp)
jmp 0x6daf
movl -0x8(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x28(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movl -0x1c(%rsp), %eax
subl $0x1, %eax
shrl %eax
cmpl $0x0, %eax
je 0x6df7
movl -0x4(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
shrl %ecx
shll %cl, %eax
movl -0x4(%rsp), %edx
movl -0x1c(%rsp), %esi
subl $0x1, %esi
shrl %esi
movl $0x20, %ecx
subl %esi, %ecx
shrl %cl, %edx
movl %edx, %ecx
xorl %ecx, %eax
movl %eax, -0x2c(%rsp)
jmp 0x6dff
movl -0x4(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
cmpl $0x19, 0x2c(%rsp)
jae 0x6eaf
cmpl $0x8, 0x14(%rsp)
jae 0x6eaf
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0x8, %eax
ja 0x6eaf
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
leaq 0x8(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %r8d
callq 0x5030
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x6ead
movq 0x20(%rsp), %rax
movl 0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl 0x4(%rsp), %ecx
movzbl 0x8(%rsp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6e70
jmp 0x6eaf
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)