LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: consumer
int consumer(void *ctx)
{
	printf("consumer\n"); 	//DELETEME
	struct spsc_ub_queue *q = (struct spsc_ub_queue *) ctx;
	
	srand((unsigned) time(0) + thread_get_id());
	size_t pause = rand() % 1000;

	/* Wait for global start signal */
	while (g_start == 0)
		thrd_yield();
	
		/* Wait for a random time */
	for (size_t i = 0; i != pause; i += 1)
		nop();
	
	/* Dequeue */
	for (unsigned long count = 0, n1 = 0, n2 = 1; count < N; count++) {
		int fib = n1 + n2;
		int *pulled;
		
		while (!spsc_ub_queue_pull(q, (void **) &pulled)) {
			//printf("Queue empty: %d\n", temp);
			//return -1;
		}
		
		if (*pulled != fib) {
			printf("Pulled != fib\n");
			return -1;
		}		
		
		n1 = n2; n2 = fib;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd93(%rip), %rdi       # 0x2055
callq 0x1040
xorl %edi, %edi
callq 0x1090
leal -0x1(%rax), %edi
callq 0x1080
callq 0x10f0
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movl %edx, %ebp
cmpl $0x0, 0x2db4(%rip)      # 0x40a0
jne 0x12f5
callq 0x1070
jmp 0x12e5
movslq %ebp, %rax
subq $0x1, %rax
jb 0x1302
pause
jmp 0x12f8
pushq $0x1
popq %r12
xorl %r15d, %r15d
movq %rsp, %r14
xorl %r13d, %r13d
cmpq $0x1312d00, %r15        # imm = 0x1312D00
je 0x134d
addq %r12, %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15ef
testl %eax, %eax
je 0x131b
movq (%rsp), %rax
cmpl %r13d, (%rax)
jne 0x1341
movslq %r13d, %rax
incq %r15
movq %r12, %r13
movq %rax, %r12
jmp 0x130f
leaq 0xd16(%rip), %rdi       # 0x205e
callq 0x1040
xorl %eax, %eax
cmpq $0x1312d00, %r15        # imm = 0x1312D00
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: test_single_threaded
int test_single_threaded(struct spsc_ub_queue *q)
{
	int resp, resc;
	
	resp = producer(q);
	if (resp)
		printf("Enqueuing failed\n");
	
	resc = consumer(q);
	if (resc)
		printf("Consumer failed\n");
	
	if (resc || resp)
		printf("Single Thread Test Failed\n");
	else
		printf("Single Thread Test Complete\n");
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x1200
movl %eax, %ebx
testl %eax, %eax
je 0x1385
leaq 0xcec(%rip), %rdi       # 0x206c
callq 0x1040
movq %r14, %rdi
callq 0x12ad
movl %eax, %ebp
testl %eax, %eax
je 0x139f
leaq 0xce3(%rip), %rdi       # 0x207d
callq 0x1040
orl %ebx, %ebp
leaq 0xce5(%rip), %rax       # 0x208d
leaq 0xcfa(%rip), %rdi       # 0x20a9
cmoveq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_test_fib.c
// Function: test_multi_threaded
int test_multi_threaded(struct spsc_ub_queue *q)
{
	thrd_t thrp, thrc;
	int resp, resc;
	
	g_start = 0;
	
	thrd_create(&thrp, consumer, q);	/** @todo Why producer thread runs earlier? */
	thrd_create(&thrc, producer, q);
	
	sleep(1);

	uint64_t start_tsc_time, end_tsc_time;

	start_tsc_time = rdtscp();
	g_start = 1;

	thrd_join(thrp, &resp);
	thrd_join(thrc, &resc);
	
	end_tsc_time = rdtscp();

	if (resc || resp)
		printf("Queue Test failed\n");
	else
		printf("Two-thread Test Complete\n");

	printf("cycles/op for rdtsc %lu\n", (end_tsc_time - start_tsc_time)/N);
	
	if (q->_tail->_next != NULL)
		printf("slots in use? There is something wrong with the test\n");
	
	int ret = spsc_ub_queue_destroy(q);
	if (ret)
		printf("Failed to destroy queue: %d\n", ret);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, 0x2cc7(%rip)      # 0x40a0
leaq -0x133(%rip), %rsi      # 0x12ad
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0x14d5
leaq -0x1f7(%rip), %rsi      # 0x1200
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x14d5
pushq $0x1
popq %rdi
callq 0x10e0
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r14
movl $0x1, 0x2c7b(%rip)      # 0x40a0
movq (%r15), %rdi
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x14e2
movq (%r12), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x14e2
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, %r13
movl (%r15), %eax
orl (%r12), %eax
leaq 0xc7c(%rip), %rax       # 0x20dc
leaq 0xc5c(%rip), %rdi       # 0x20c3
cmovneq %rax, %rdi
callq 0x1040
subq %r14, %r13
movl $0x1312d00, %ecx        # imm = 0x1312D00
movq %r13, %rax
xorl %edx, %edx
divq %rcx
leaq 0xb7d(%rip), %rdi       # 0x2004
movq %rax, %rsi
xorl %eax, %eax
callq 0x1060
movq 0x48(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x14a9
leaq 0xc4a(%rip), %rdi       # 0x20ee
callq 0x1040
movq %rbx, %rdi
callq 0x161b
testl %eax, %eax
je 0x14c5
leaq 0xb61(%rip), %rdi       # 0x201d
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_init
int spsc_ub_queue_init(struct spsc_ub_queue* q, size_t size, const struct memtype *mem)
{
	q->mem = mem;
	struct node* n = memory_alloc(q->mem, sizeof(struct node) * size);
	n->_next = NULL;
	q->_tail = q->_head = q->_first= q->_tailcopy = n;
	
	/** Alloc memory at start for total size for efficiency */
	void *v = NULL;
	for(unsigned long i = 0; i < size; i++)		/** @todo fix this hack in bounded implementation */
		spsc_ub_queue_push(q, v);
	for(unsigned long i = 0; i < size; i++)
		spsc_ub_queue_pull(q, &v);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, (%rdi)
shlq $0x4, %rsi
movq %rdx, %rdi
callq 0x168c
xorl %ecx, %ecx
xchgq %rcx, (%rax)
movq %rax, 0x120(%r14)
movq %rax, 0xd8(%r14)
movq %rax, 0x90(%r14)
xchgq %rax, 0x48(%r14)
movq %rbx, %r15
subq $0x1, %r15
jb 0x1595
movq %r14, %rdi
xorl %esi, %esi
callq 0x15b9
jmp 0x1583
leaq 0x8(%rsp), %r15
subq $0x1, %rbx
jb 0x15ad
movq %r14, %rdi
movq %r15, %rsi
callq 0x15ef
jmp 0x159a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_push
int spsc_ub_queue_push(struct spsc_ub_queue* q, void * v)
{
	struct node* n = spsc_ub_alloc_node(q);
	
	atomic_store_explicit(&(n->_next), NULL, memory_order_release);
	//n->_next = NULL;
	n->_value = v;
	
	//store_release(&(q->_head->_next), n);
	atomic_store_explicit(&(q->_head->_next), n, memory_order_release);
	
	q->_head = n;
	
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x164c
movq $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq 0x90(%r14), %rcx
movq %rax, (%rcx)
movq %rax, 0x90(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/stv0g[P]c11-queues/spsc_ub_queue.c
// Function: spsc_ub_queue_destroy
int spsc_ub_queue_destroy(struct spsc_ub_queue* q)
{
	struct node* n = q->_first;

	do {
		struct node* next = n->_next;
		memory_free(q->mem, (void *) n, sizeof(struct node));
		n = next;
	} while (n);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xd8(%rdi), %rsi
pushq $0x10
popq %r14
movq (%rsi), %r15
movq (%rbx), %rdi
movq %r14, %rdx
callq 0x1695
movq %r15, %rsi
testq %r15, %r15
jne 0x162e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/brk2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long page_size = getpagesize();
	void *addr = sbrk(page_size) + page_size;

	while (1) {
		addr += page_size;
		assert(brk(addr) == 0);

		addr -= page_size;
		assert(brk(addr) == 0);

		(*iterations) += 2;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1270
movslq %eax, %r14
movq %r14, %rdi
callq 0x1180
movq %rax, %r15
addq %r14, %r15
addq %r15, %r14
movq %r14, %rdi
callq 0x1170
testl %eax, %eax
jne 0x1c0f
movq %r15, %rdi
callq 0x1170
testl %eax, %eax
jne 0x1c28
addq $0x2, (%rbx)
jmp 0x1bf1
leaq 0x66d(%rip), %rdi       # 0x2283
leaq 0x675(%rip), %rsi       # 0x2292
leaq 0x67b(%rip), %rcx       # 0x229f
pushq $0xe
jmp 0x1c3f
leaq 0x654(%rip), %rdi       # 0x2283
leaq 0x65c(%rip), %rsi       # 0x2292
leaq 0x662(%rip), %rcx       # 0x229f
pushq $0x11
popq %rdx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: pr_ypart(char const*)
static void pr_ypart(const char* vs) { /* output contribution from Y vec */
  for (int i = 0; i < npoles; i++) {
    if (i % 2 == 0)
      prnl();
    printf(" + (%14.10f * %s[%d])", ycoeffs[i], vs, i);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4933(%rip), %r12      # 0x6210
xorl %r14d, %r14d
leaq 0x186f(%rip), %r15      # 0x3156
movslq 0x491a(%rip), %rax      # 0x6208
cmpq %rax, %r14
jge 0x191d
testb $0x1, %r14b
jne 0x18fe
callq 0x1ac4
movsd (%r12), %xmm0
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movb $0x1, %al
callq 0x1030
incq %r14
addq $0x8, %r12
jmp 0x18e7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: pr_xpart(char const*)
static void pr_xpart(const char* vs) { /* output contribution from X vec */
  nxfacs = 0;
  for (int i = 0; i < (nzeros + 1) / 2; i++) {
    int j = nzeros - i;
    double xi = xcoeffs[i], xj = xcoeffs[j];
    /* they should be paired, except for allpass resonator */
    if (xi == xj) {
      unless(xi == 0.0) {
        prxfac(xi);
        printf("(%s[%d] + %s[%d])", vs, i, vs, j);
      }
    } else if (xi == -xj) {
      if (xi > 0.0) {
        prxfac(xi);
        printf("(%s[%d] - %s[%d])", vs, i, vs, j);
      } else {
        prxfac(xj);
        printf("(%s[%d] - %s[%d])", vs, j, vs, i);
      }
    } else {
      unless(xi == 0.0) {
        prxfac(xi);
        printf("%s[%d]", vs, i);
      }
      unless(xj == 0.0) {
        prxfac(xj);
        printf("%s[%d]", vs, j);
      }
    }
  }
  if ((nzeros + 1) & 1) {
    int j = nzeros / 2;
    double xj = xcoeffs[j];
    unless(xj == 0.0) {
      prxfac(xj);
      printf("%s[%d]", vs, j);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
andl $0x0, 0x58de(%rip)      # 0x721c
movq %rdi, %rbx
leaq 0x38b8(%rip), %r15      # 0x5200
xorpd %xmm2, %xmm2
xorl %r14d, %r14d
xorl %r13d, %r13d
movl 0x3897(%rip), %r12d     # 0x51f0
leal 0x1(%r12), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
cltq
cmpq %rax, %r13
jge 0x1a6a
leaq (%r14,%r12), %rbp
movsd (%r15), %xmm0
movslq %r12d, %rax
addq %r14, %rax
leaq 0x387b(%rip), %rcx      # 0x5200
movsd (%rcx,%rax,8), %xmm3
ucomisd %xmm3, %xmm0
jne 0x19ac
jp 0x19ac
ucomisd %xmm2, %xmm0
jne 0x199e
jnp 0x1a5b
callq 0x1aee
leaq 0x17c2(%rip), %rdi      # 0x316c
jmp 0x19d2
movapd %xmm3, %xmm1
xorpd 0x1668(%rip), %xmm1     # 0x3020
ucomisd %xmm1, %xmm0
jne 0x19e0
jp 0x19e0
ucomisd %xmm2, %xmm0
jbe 0x1a35
callq 0x1aee
leaq 0x17ac(%rip), %rdi      # 0x317e
movq %rbx, %rsi
movl %r13d, %edx
movq %rbx, %rcx
movl %ebp, %r8d
jmp 0x1a50
ucomisd %xmm2, %xmm0
jne 0x19e8
jnp 0x1a0f
movapd %xmm3, (%rsp)
callq 0x1aee
leaq 0x1797(%rip), %rdi      # 0x3190
movq %rbx, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x1030
movapd (%rsp), %xmm3
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm3
jne 0x1a17
jnp 0x1a5b
movapd %xmm3, %xmm0
callq 0x1aee
leaq 0x1769(%rip), %rdi      # 0x3190
movq %rbx, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1030
jmp 0x1a57
movapd %xmm3, %xmm0
callq 0x1aee
leaq 0x1739(%rip), %rdi      # 0x317e
movq %rbx, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x1030
xorpd %xmm2, %xmm2
incq %r13
addq $0x8, %r15
decq %r14
jmp 0x1952
testb $0x1, %r12b
jne 0x1a8e
sarl %r12d
movslq %r12d, %rax
leaq 0x3783(%rip), %rcx      # 0x5200
movsd (%rcx,%rax,8), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1a9d
jp 0x1a9d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1aee
leaq 0x16e7(%rip), %rdi      # 0x3190
movq %rbx, %rsi
movl %r12d, %edx
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/gencode.C
// Function: prxfac(double)
static void prxfac(double x) {
  if (nxfacs > 0 && nxfacs % 3 == 0)
    prnl();
  if (x > 0.0)
    printf((nxfacs > 0) ? " + " : "   ");
  if (x < 0.0) {
    printf(" - ");
    x = -x;
  }
  unless(x == 1.0) {
    double f = fmod(x, 1.0);
    const char* fmt = (f < EPS || f > 1.0 - EPS) ? "%g" : "%14.10f";
    printf(fmt, x);
    printf(" * ");
  }
  nxfacs++;
}

// Assembly:
subq $0x18, %rsp
movl 0x5724(%rip), %ecx      # 0x721c
pushq $0x3
popq %rsi
movl %ecx, %eax
xorl %edx, %edx
divl %esi
testl %ecx, %ecx
movapd %xmm0, (%rsp)
jle 0x1b18
testl %edx, %edx
jne 0x1b18
callq 0x1ac4
movapd (%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1b4b
cmpl $0x0, 0x56f3(%rip)      # 0x721c
leaq 0x1667(%rip), %rax      # 0x3197
leaq 0x16e1(%rip), %rdi      # 0x3218
cmovgq %rax, %rdi
xorl %eax, %eax
callq 0x1030
xorpd %xmm1, %xmm1
movapd (%rsp), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x1b6c
leaq 0x1643(%rip), %rdi      # 0x319b
xorl %eax, %eax
callq 0x1030
movapd (%rsp), %xmm0
xorpd 0x14b4(%rip), %xmm0     # 0x3020
ucomisd 0x1494(%rip), %xmm0     # 0x3008
jne 0x1b78
jnp 0x1bce
movsd 0x1488(%rip), %xmm1     # 0x3008
movapd %xmm0, (%rsp)
callq 0x10b0
ucomisd 0x147e(%rip), %xmm0     # 0x3010
leaq 0x1606(%rip), %rax      # 0x319f
leaq 0x1602(%rip), %rdi      # 0x31a2
cmovaq %rax, %rdi
movsd 0x146c(%rip), %xmm1     # 0x3018
ucomisd %xmm0, %xmm1
cmovaq %rax, %rdi
movapd (%rsp), %xmm0
movb $0x1, %al
callq 0x1030
leaq 0x15e3(%rip), %rdi      # 0x31aa
xorl %eax, %eax
callq 0x1030
incl 0x5648(%rip)            # 0x721c
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: rdline(char*)
static void rdline(char vec[]) {
  int n = 0;
  int ch = getchar();
  until(n >= MAXSTRING || ch == '\n' || ch < 0) {
    vec[n++] = ch;
    ch = getchar();
  }
  if (n == 0 && ch < 0)
    formaterror(6);
  vec[n] = '\0';
  until(ch == '\n' || ch < 0) ch = getchar();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
callq 0x10c0
testl %eax, %eax
js 0x1f30
cmpq $0xff, %r14
ja 0x1f30
cmpl $0xa, %eax
je 0x1f30
movb %al, (%rbx,%r14)
incq %r14
jmp 0x1f10
testq %r14, %r14
setne %cl
testl %eax, %eax
setns %dl
orb %cl, %dl
je 0x1f5c
movb $0x0, (%rbx,%r14)
cmpl $0xa, %eax
je 0x1f54
testl %eax, %eax
js 0x1f54
callq 0x10c0
jmp 0x1f44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x6
popq %rdi
callq 0x2033
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: rdcoeffs(char, int&, double*)
static void rdcoeffs(char c, int& n, double* coeffs) {
  char fmt[6];
  strcpy(fmt, "N? = ");
  fmt[1] = c;
  n = rdint(fmt);
  unless(n >= 0 && n <= MAXPZ) formaterror(3);
  for (int i = 0; i <= n; i++)
    coeffs[i] = rddouble("");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %rcx
movl $0x3d203f4e, (%rcx)     # imm = 0x3D203F4E
movw $0x20, 0x4(%rcx)
movb %dil, 0x1(%rcx)
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %r15
pushq $0x4
popq %rdx
movq %r15, %rsi
callq 0x2060
movslq (%r15), %rax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
callq 0x1110
movl %eax, (%r14)
cmpl $0x200, %eax            # imm = 0x200
ja 0x202b
xorl %r12d, %r12d
leaq 0x11cf(%rip), %r15      # 0x31ce
cltq
cmpq %rax, %r12
jg 0x201c
movq %r15, %rdi
callq 0x1f64
movsd %xmm0, (%rbx,%r12,8)
incq %r12
movl (%r14), %eax
jmp 0x1fff
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x3
popq %rdi
callq 0x2033
// File: /workspace/github_c_makefile_star2_O2/randyrossi[P]fisher-modem/mkfilter/src/readdata.C
// Function: getline(char*, int&, int, char const*)
static void getline(char* vec, int& p, int e, const char* exp) {
  rdline(vec);
  p = strlen(exp);
  unless(memcmp(vec, exp, p) == 0) formaterror(e);
  while (vec[p] == ' ' || vec[p] == '\t')
    p++;
  unless((vec[p] >= '0' && vec[p] <= '9') || (vec[p] == '+') ||
         (vec[p] == '-') || (vec[p] == '.')) formaterror(e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r13
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1f06
movq %r13, %rdi
callq 0x1060
movq %rax, %r12
movl %r12d, (%r14)
movslq %r12d, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x1080
testl %eax, %eax
jne 0x20df
movslq %r12d, %rax
addq %rax, %r15
incl %eax
movzbl (%r15), %ecx
cmpl $0x20, %ecx
je 0x20af
cmpl $0x9, %ecx
jne 0x20b7
movl %eax, (%r14)
incq %r15
jmp 0x209f
leal -0x30(%rcx), %eax
cmpb $0xa, %al
jb 0x20d5
cmpl $0x2e, %ecx
ja 0x20df
movl %ecx, %eax
movabsq $0x680000000000, %rcx   # imm = 0x680000000000
btq %rax, %rcx
jae 0x20df
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %ebx, %edi
callq 0x2033
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/matrix_lookup.c
// Function: parasail_matrix_lookup
const parasail_matrix_t* parasail_matrix_lookup(const char *matrixname)
{
    const parasail_matrix_t *matrix = NULL;

    if (matrixname) {
        int index = 0;
        const parasail_matrix_t *current = parasail_matrices[index++];
        while (current) {
            if (0 == strcmp(matrixname, current->name)) {
                matrix = current;
                break;
            }
            current = parasail_matrices[index++];
        }
    }

    return matrix;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12e64c
movq %rdi, %r14
leaq 0x4ce475(%rip), %rbx    # 0x5fca98
pushq $0x1
popq %r15
leaq 0x4ce242(%rip), %r12    # 0x5fc870
cmpq $0x45, %r15
je 0x12e64c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1291a0
testl %eax, %eax
je 0x12e64e
movq (%r12,%r15,8), %rbx
incq %r15
jmp 0x12e62e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/parser.c
// Function: strdup_rpl
static char* strdup_rpl(const char *str)
{
    size_t l = strlen(str);
    char *s = (char*)calloc(l + 1, sizeof(char));
    if(!s) {
        return NULL;
    }
    (void)memcpy(s, str, l);
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1290a0
movq %rax, %r14
leaq 0x1(%rax), %rdi
pushq $0x1
popq %rsi
callq 0x1290e0
testq %rax, %rax
je 0x1310d0
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x129100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/parser.c
// Function: parasail_sequences_free
void parasail_sequences_free(parasail_sequences_t *sequences)
{
    size_t i;
    for (i=0; i<sequences->l; ++i) {
        if (sequences->seqs[i].name.s)    free(sequences->seqs[i].name.s);
        if (sequences->seqs[i].comment.s) free(sequences->seqs[i].comment.s);
        if (sequences->seqs[i].seq.s)     free(sequences->seqs[i].seq.s);
        if (sequences->seqs[i].qual.s)    free(sequences->seqs[i].qual.s);
    }
    free(sequences->seqs);
    free(sequences);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r15
jae 0x131129
movq 0x8(%rdi,%r14), %rdi
callq 0x129170
movq (%rbx), %rax
movq 0x18(%rax,%r14), %rdi
callq 0x129170
movq (%rbx), %rax
movq 0x28(%rax,%r14), %rdi
callq 0x129170
movq (%rbx), %rax
movq 0x38(%rax,%r14), %rdi
callq 0x129170
incq %r15
addq $0x40, %r14
jmp 0x1310e6
callq 0x129170
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x129170
// File: /workspace/github_c_makefile_star2_O2/nh13[P]ksw/src/parasail/src/parser.c
// Function: parasail_sequences_pack
char* parasail_sequences_pack(const parasail_sequences_t *sequences, size_t *size)
{
    size_t i = 0;
    size_t offset = 0;
    char *packed = NULL;

    packed = (char*)malloc(sizeof(char) * (sequences->characters+sequences->l+1));
    if (NULL == packed) {
        perror("malloc");
        fprintf(stderr, "parasail_sequences_pack: failed\n");
        return NULL;
    }

    for (i=0; i<sequences->l; ++i) {
        memcpy(&packed[offset], sequences->seqs[i].seq.s, sequences->seqs[i].seq.l);
        offset += sequences->seqs[i].seq.l;
        packed[offset++] = '$';
    }
    packed[offset] = '\0';

    *size = offset;

    return packed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rax
leaq (%rax,%r13), %rdi
incq %rdi
callq 0x129190
movq %rax, %rbx
testq %rax, %rax
je 0x1311c0
movq %r14, (%rsp)
pushq $0x28
popq %r14
xorl %ebp, %ebp
leaq (%rbx,%rbp), %rdi
subq $0x1, %r13
jb 0x1311a4
movq (%r15), %rax
movq -0x8(%rax,%r14), %r12
movq (%rax,%r14), %rsi
movq %r12, %rdx
callq 0x129100
leaq (%r12,%rbp), %rax
addq %r12, %rbp
incq %rbp
movb $0x24, (%rbx,%rax)
addq $0x40, %r14
jmp 0x131172
movb $0x0, (%rdi)
movq (%rsp), %rax
movq %rbp, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3fd959(%rip), %rdi    # 0x52eb20
callq 0x129110
movq 0x4cce0d(%rip), %rax    # 0x5fdfe0
movq (%rax), %rcx
leaq 0x3fd9b6(%rip), %rdi    # 0x52eb93
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
callq 0x129220
jmp 0x1311ae
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/benes.c
// Function: layer_ex
static void layer_ex(uint64_t * data, uint64_t * bits, int lgs)
{
	int i, j, s;

	uint64_t d;

	s = 1 << lgs;

	for (i = 0; i < 128; i += s*2)
	for (j = i; j < i+s; j++)
	{

		d = (data[j+0] ^ data[j+s]);
		d &= (*bits++);
		data[j+0] ^= d;
		data[j+s] ^= d;
	}
}

// Assembly:
pushq %r14
pushq %rbx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl $0x2, %eax
shll %cl, %eax
cltq
movslq %edx, %rcx
leaq (%rdi,%rcx,8), %rdx
xorl %r8d, %r8d
cmpq $0x7f, %r8
jg 0x17de
leaq (%r8,%rcx), %r9
movq %r8, %r10
cmpq %r9, %r10
jge 0x17d9
movq (%rdi,%r10,8), %r11
movq (%rdx,%r10,8), %rbx
movq %rbx, %r14
xorq %r11, %r14
andq (%rsi), %r14
addq $0x8, %rsi
xorq %r14, %r11
movq %r11, (%rdi,%r10,8)
xorq %rbx, %r14
movq %r14, (%rdx,%r10,8)
incq %r10
jmp 0x17ac
addq %rax, %r8
jmp 0x179f
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/benes.c
// Function: layer_in
static void layer_in(uint64_t data[2][64], uint64_t * bits, int lgs)
{
	int i, j, s;

	uint64_t d;

	s = 1 << lgs;

	for (i = 0; i < 64; i += s*2)
	for (j = i; j < i+s; j++)
	{

		d = (data[0][j+0] ^ data[0][j+s]);
		d &= (*bits++);
		data[0][j+0] ^= d;
		data[0][j+s] ^= d;

		d = (data[1][j+0] ^ data[1][j+s]);
		d &= (*bits++);
		data[1][j+0] ^= d;
		data[1][j+s] ^= d;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
addq $0x200, %rdi            # imm = 0x200
movl $0x2, %eax
shll %cl, %eax
cltq
movslq %edx, %rcx
leaq (,%rax,8), %rdx
xorl %r8d, %r8d
cmpq $0x3f, %r8
jg 0x1883
leaq (%r8,%rcx), %r9
movq %rdi, %r10
movq %r8, %r11
cmpq %r9, %r11
jge 0x187b
movq -0x200(%r10), %rbx
movq -0x200(%r10,%rcx,8), %r14
movq %r14, %r15
xorq %rbx, %r15
andq (%rsi), %r15
xorq %r15, %rbx
movq %rbx, -0x200(%r10)
xorq %r14, %r15
movq %r15, -0x200(%r10,%rcx,8)
movq (%r10), %rbx
movq (%r10,%rcx,8), %r14
movq %r14, %r15
xorq %rbx, %r15
andq 0x8(%rsi), %r15
addq $0x10, %rsi
xorq %r15, %rbx
movq %rbx, (%r10)
xorq %r14, %r15
movq %r15, (%r10,%rcx,8)
incq %r11
addq $0x8, %r10
jmp 0x181e
addq %rax, %r8
addq %rdx, %rdi
jmp 0x180e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/benes.c
// Function: support_gen
void support_gen(gf * s, const unsigned char *c)
{
	gf a;
	int i, j;
	unsigned char L[ GFBITS ][ (1 << GFBITS)/8 ];

	for (i = 0; i < GFBITS; i++)
		for (j = 0; j < (1 << GFBITS)/8; j++)
			L[i][j] = 0;

	for (i = 0; i < (1 << GFBITS); i++)
	{
		a = bitrev((gf) i);

		for (j = 0; j < GFBITS; j++)
			L[j][ i/8 ] |= ((a >> j) & 1) << (i%8);
	}
			
	for (j = 0; j < GFBITS; j++)
		apply_benes(L[j], c, 0);

	for (i = 0; i < SYS_N; i++)
	{
		a = bitrev((gf) i);
	
		s[i] = 0;
		for (j = GFBITS-1; j >= 0; j--)
		{
			s[i] <<= 1;
			s[i] |= (L[j][i/8] >> (i%8)) & 1;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x3400, %rsp           # imm = 0x3400
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
xorl %ecx, %ecx
cmpq $0xd, %rcx
je 0x18c8
xorl %edx, %edx
cmpq $0x400, %rdx            # imm = 0x400
je 0x18bd
movb $0x0, (%rax,%rdx)
incq %rdx
jmp 0x18ab
incq %rcx
addq $0x400, %rax            # imm = 0x400
jmp 0x18a3
xorl %r15d, %r15d
cmpl $0x2000, %r15d          # imm = 0x2000
je 0x1919
movq %r15, %rax
shrq $0x3, %rax
leaq (%rsp,%rax), %r12
movzwl %r15w, %edi
callq 0x65f1
movzwl %ax, %eax
movl %r15d, %ecx
andl $0x7, %ecx
xorl %edx, %edx
cmpq $0xd, %rdx
je 0x1914
xorl %esi, %esi
btl %edx, %eax
setb %sil
shll %cl, %esi
orb %sil, (%r12)
incq %rdx
addq $0x400, %r12            # imm = 0x400
jmp 0x18f3
incq %r15
jmp 0x18cb
xorl %r15d, %r15d
cmpq $0x3400, %r15           # imm = 0x3400
je 0x193c
leaq (%rsp,%r15), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x14e8
addq $0x400, %r15            # imm = 0x400
jmp 0x191c
xorl %r14d, %r14d
pushq $0xc
popq %rbp
cmpq $0x2000, %r14           # imm = 0x2000
je 0x1991
movzwl %r14w, %edi
callq 0x65f1
movl %r14d, %eax
shrl $0x3, %eax
movl %r14d, %ecx
andl $0x7, %ecx
xorl %edx, %edx
movl %ebp, %esi
testl %esi, %esi
js 0x1987
movl %esi, %edi
shlq $0xa, %rdi
addq %rsp, %rdi
movzbl (%rax,%rdi), %edi
xorl %r8d, %r8d
btl %ecx, %edi
setb %r8b
leal (%r8,%rdx,2), %edx
decl %esi
jmp 0x1964
movw %dx, (%rbx,%r14,2)
incq %r14
jmp 0x1942
addq $0x3400, %rsp           # imm = 0x3400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/checkfd.c
// Function: checkfd
int checkfd(int fd, short event) {

    struct pollfd p;
    char ch = 0;
    int r;
    struct stat st;

    if (fstat(fd, &st) != 0) return 0;

    p.fd = fd;
    p.events = event;
    p.revents = 0;
    for (;;) {
        r = poll(&p, 1, 0);
        if (r == -1) {
            if (errno == EAGAIN) continue;
            if (errno == EINTR) continue;
        }
        if (r != 1) return 0;
        if (r == 1) break;
    }
    if (p.revents) return 1;
    /* catch errno */
    if (event == POLLOUT)
        r = write(fd, &ch, 1);
    if (event == POLLIN)
        r = read(fd, &ch, 1);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %esi, %r14d
movl %edi, %ebp
movb $0x0, 0x7(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1110
xorl %ebx, %ebx
testl %eax, %eax
je 0x3ab3
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %r15
movl %ebp, (%r15)
movw %r14w, 0x4(%r15)
andw $0x0, 0x6(%r15)
pushq $0x1
popq %r12
xorl %ebx, %ebx
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x10d0
cmpl $-0x1, %eax
jne 0x3af1
callq 0x1040
movl (%rax), %eax
cmpl $0x4, %eax
je 0x3acc
cmpl $0xb, %eax
je 0x3acc
jmp 0x3aa1
cmpl $0x1, %eax
jne 0x3aa1
cmpw $0x0, 0xe(%rsp)
je 0x3b03
pushq $0x1
popq %rbx
jmp 0x3aa1
movswl %r14w, %eax
cmpl $0x1, %eax
je 0x3b25
cmpl $0x4, %eax
jne 0x3aa1
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rdx
movl %ebp, %edi
callq 0x1060
jmp 0x3aa1
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rdx
movl %ebp, %edi
callq 0x1090
jmp 0x3aa1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: controlbits
void controlbits(unsigned char * out)
{
	int i;
	uint32_t pi[ (1 << GFBITS) ];
	unsigned char c[ (2*GFBITS - 1) * (1 << GFBITS) / 16 ];

	perm_gen(pi);

	for (i = 0; i < sizeof(c); i++)
		c[i] = 0;

	controlbitsfrompermutation(GFBITS, (1 << GFBITS), 1, 0, c, pi);

	for (i = 0; i < sizeof(c); i++)
		out[i] = c[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18008, %rsp          # imm = 0x18008
movq %rdi, %rbx
movq %rsp, %r14
pushq $0x1
popq %r15
pushq $0x1
popq %rbp
movl $0x10000, %esi          # imm = 0x10000
movq %r14, %rdi
callq 0x5fcc
xorl %eax, %eax
cmpq $0x2000, %rax           # imm = 0x2000
je 0x3b81
movq (%rsp,%rax,8), %rcx
shlq $0xd, %rcx
addq %rax, %rcx
movq %rcx, (%rsp,%rax,8)
incq %rax
jmp 0x3b65
xorl %eax, %eax
movq %r15, %rcx
cmpq $0x2000, %rcx           # imm = 0x2000
je 0x3bb5
movq (%rsp,%rcx,8), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x3bb0
movq (%rsp,%rsi,8), %rdi
xorq %rdx, %rdi
cmpq $0x2000, %rdi           # imm = 0x2000
cmovbl %ebp, %eax
incq %rsi
jmp 0x3b95
incq %rcx
jmp 0x3b86
testl %eax, %eax
jne 0x3b56
movq %rsp, %rsi
movl $0x2000, %edi           # imm = 0x2000
callq 0x4046
xorl %eax, %eax
movl $0x1fff, %ecx           # imm = 0x1FFF
cmpq $0x2000, %rax           # imm = 0x2000
je 0x3be6
movl (%rsp,%rax,8), %edx
andl %ecx, %edx
movl %edx, 0x10000(%rsp,%rax,4)
incq %rax
jmp 0x3bcd
xorl %eax, %eax
cmpq $0x3200, %rax           # imm = 0x3200
je 0x3bf9
movb $0x0, (%rsp,%rax)
incq %rax
jmp 0x3be8
pushq $0xd
popq %rdi
pushq $0x1
popq %rdx
xorl %r14d, %r14d
movq %rsp, %r8
leaq 0x10000(%rsp), %r9
movl $0x2000, %esi           # imm = 0x2000
xorl %ecx, %ecx
callq 0x3c3d
cmpq $0x3200, %r14           # imm = 0x3200
je 0x3c2f
movb (%rsp,%r14), %al
movb %al, (%rbx,%r14)
incq %r14
jmp 0x3c19
addq $0x18008, %rsp          # imm = 0x18008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: sort_64b
static void sort_64b(int n, uint64_t x[n])
{
  if (n <= 1) return;
  sort_64b(n/2,x);
  sort_64b(n/2,x + n/2);
  merge_64b(n/2,x,1);
}

// Assembly:
cmpl $0x1, %edi
jg 0x404c
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
shrl %r14d
movl %r14d, %edi
callq 0x4046
leaq (%rbx,%r14,8), %rsi
movl %r14d, %edi
callq 0x4046
pushq $0x1
popq %rdx
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x407f
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: merge_64b
static void merge_64b(int n,uint64_t x[n],int step)
{
  int i;
  if (n == 1)
    minmax_64b(&x[0],&x[step]);
  else {
    merge_64b(n / 2,x,step * 2);
    merge_64b(n / 2,x + step,step * 2);
    for (i = 1;i < 2*n-1;i += 2)
      minmax_64b(&x[i * step],&x[(i + 1) * step]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
cmpl $0x1, %edi
jne 0x40af
movslq %r14d, %rax
leaq (%rbx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4122
movl %edi, %r15d
pushq $0x2
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movl %eax, %ebp
leal (%r14,%r14), %r12d
movl %eax, %edi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x407f
movslq %r14d, %r13
leaq (%rbx,%r13,8), %r14
movl %ebp, %edi
movq %r14, %rsi
movl %r12d, %edx
callq 0x407f
leal -0x1(,%r15,2), %eax
movslq %eax, %r15
shlq $0x4, %r13
addq %r13, %rbx
pushq $0x1
popq %r12
cmpq %r15, %r12
jge 0x4113
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4122
addq $0x2, %r12
addq %r13, %r14
addq %r13, %rbx
jmp 0x40f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: composeinv
static void composeinv(int n,uint32_t y[n],uint32_t x[n],uint32_t pi[n]) /* // NC */
{
  int i;
  uint32_t t[n];

  for (i = 0;i < n;++i) 
    t[i] = x[i] | (pi[i] << 16);

  sort(n,t);

  for (i = 0;i < n;++i)
    y[i] = t[i] & 0xFFFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %eax
movq %rsp, %r14
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
xorl %eax, %eax
testl %edi, %edi
movl $0x0, %r15d
cmovgl %edi, %r15d
cmpq %rax, %r15
je 0x4194
movl (%rcx,%rax,4), %esi
shll $0x10, %esi
orl (%rdx,%rax,4), %esi
movl %esi, (%r14,%rax,4)
incq %rax
jmp 0x417d
movq %r14, %rsi
callq 0x4202
xorl %eax, %eax
cmpq %rax, %r15
je 0x41b0
movzwl (%r14,%rax,4), %ecx
movl %ecx, (%rbx,%rax,4)
incq %rax
jmp 0x419e
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: flow
static void flow(int w, uint32_t *x, uint32_t *y, const int t)
{
  bit m0;
  bit m1;

  uint32_t b;
  uint32_t y_copy = *y;

  m0 = is_smaller(*y & ((1<<w)-1), *x & ((1<<w)-1));
  m1 = is_smaller(0, t);

  cswap(x, &y_copy, m0);
  b = m0 & m1;
  *x ^= b << w;
}

// Assembly:
movl %ecx, %eax
movl %edi, %ecx
movl (%rdx), %edx
pushq $-0x1
popq %rdi
shll %cl, %edi
notl %edi
movl %edx, %r8d
andl %edi, %r8d
movl (%rsi), %r9d
andl %r9d, %edi
negl %eax
shrl $0x1f, %eax
xorl %r10d, %r10d
cmpl %edi, %r8d
cmovbl %edx, %r9d
cmovbl %eax, %r10d
shll %cl, %r10d
xorl %r9d, %r10d
movl %r10d, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: sort
static void sort(int n, uint32_t x[n])
{
  if (n <= 1) return;
  sort(n/2,x);
  sort(n/2,x + n/2);
  merge(n/2,x,1);
}

// Assembly:
cmpl $0x1, %edi
jg 0x4208
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
shrl %r14d
movl %r14d, %edi
callq 0x4202
leaq (%rbx,%r14,4), %rsi
movl %r14d, %edi
callq 0x4202
pushq $0x1
popq %rdx
movl %r14d, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x423b
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/controlbits.c
// Function: merge
static void merge(int n,uint32_t x[n],int step)
{
  int i;
  if (n == 1)
    minmax(&x[0],&x[step]);
  else {
    merge(n / 2,x,step * 2);
    merge(n / 2,x + step,step * 2);
    for (i = 1;i < 2*n-1;i += 2)
      minmax(&x[i * step],&x[(i + 1) * step]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
cmpl $0x1, %edi
jne 0x426a
movslq %ebx, %rax
leaq (%r14,%rax,4), %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42de
movl %edi, %r15d
pushq $0x2
popq %rcx
movl %edi, %eax
cltd
idivl %ecx
movl %eax, %ebp
leal (%rbx,%rbx), %r12d
movl %eax, %edi
movq %r14, %rsi
movl %r12d, %edx
callq 0x423b
movslq %ebx, %r13
leaq (%r14,%r13,4), %rbx
movl %ebp, %edi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x423b
leal -0x1(,%r15,2), %eax
movslq %eax, %r15
leaq (%r14,%r13,8), %r14
shlq $0x3, %r13
pushq $0x1
popq %r12
cmpq %r15, %r12
jge 0x42cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42de
addq $0x2, %r12
addq %r13, %rbx
addq %r13, %r14
jmp 0x42b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/crypto_hash_sha512.c
// Function: crypto_hash_sha512
int crypto_hash_sha512(unsigned char *o,const unsigned char *m, unsigned long long n) {

    long long i;
    unsigned char x[256];
    unsigned long long b = n;
    unsigned long long h[8] = {
        0x6a09e667f3bcc908ULL, 0xbb67ae8584caa73bULL, 0x3c6ef372fe94f82bULL, 0xa54ff53a5f1d36f1ULL,
        0x510e527fade682d1ULL, 0x9b05688c2b3e6c1fULL, 0x1f83d9abfb41bd6bULL, 0x5be0cd19137e2179ULL
    };

    blocks(h, m, n);
    m += n;
    n &= 127;
    m -= n;

    for (i = 0; i < sizeof x; ++i) x[i] = 0;
    for (i = 0; i < n; ++i) x[i] = m[i];
    x[n] = 128;

    n = 256 - 128 * (n < 112);
    x[n - 9] = b >> 61;
    store64_bigendian(x + n - 8, b << 3);
    blocks(h, x, n);

    for (i = 0; i < 8; ++i) store64_bigendian(o + 8 * i, h[i]);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movaps 0x2e06(%rip), %xmm0     # 0x7110
movq %rsp, %rdi
movaps %xmm0, 0x30(%rdi)
movaps 0x2de8(%rip), %xmm0     # 0x7100
movaps %xmm0, 0x20(%rdi)
movaps 0x2dcd(%rip), %xmm0     # 0x70f0
movaps %xmm0, 0x10(%rdi)
movaps 0x2db2(%rip), %xmm0     # 0x70e0
movaps %xmm0, (%rdi)
callq 0x43ea
movl %r14d, %eax
andl $0x7f, %eax
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x4351
movb $0x0, 0x40(%rsp,%rcx)
incq %rcx
jmp 0x433e
movq %r14, %rcx
andq $-0x80, %rcx
addq %rcx, %r15
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x436f
movb (%r15,%rcx), %dl
movb %dl, 0x40(%rsp,%rcx)
incq %rcx
jmp 0x435d
movb $-0x80, 0x40(%rsp,%rax)
xorl %ecx, %ecx
cmpq $0x70, %rax
setae %cl
shll $0x7, %ecx
leaq 0x80(%rcx), %r15
movq %r14, %rax
shrq $0x3d, %rax
leaq 0x40(%rsp), %r12
movb %al, 0x77(%rcx,%r12)
leaq (%rsp,%rcx), %rdi
addq $0xb8, %rdi
shlq $0x3, %r14
movq %r14, %rsi
callq 0x45d2
movq %rsp, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x43ea
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x43d9
leaq (%rbx,%r14), %rdi
movq (%rsp,%r14), %rsi
callq 0x45d2
addq $0x8, %r14
jmp 0x43c0
xorl %eax, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/decrypt.c
// Function: decrypt
int decrypt(unsigned char *e, const unsigned char *sk, const unsigned char *c)
{
	int i, w = 0; 
	uint16_t check;	

	unsigned char r[ SYS_N/8 ];

	gf g[ SYS_T+1 ];
	gf L[ SYS_N ];

	gf s[ SYS_T*2 ];
	gf s_cmp[ SYS_T*2 ];
	gf locator[ SYS_T+1 ];
	gf images[ SYS_N ];

	gf t;

	/* // */

	for (i = 0; i < SYND_BYTES; i++)       r[i] = c[i];
	for (i = SYND_BYTES; i < SYS_N/8; i++) r[i] = 0;

	for (i = 0; i < SYS_T; i++) { g[i] = load2(sk); g[i] &= GFMASK; sk += 2; } g[ SYS_T ] = 1;

	support_gen(L, sk);

	synd(s, g, L, r);

	bm(locator, s);

	root(images, locator, L);

	/* // */
	
	for (i = 0; i < SYS_N/8; i++) 
		e[i] = 0;

	for (i = 0; i < SYS_N; i++)
	{
		t = gf_iszero(images[i]) & 1;

		e[ i/8 ] |= t << (i%8);
		w += t;

	}

	synd(s_cmp, g, L, e);

	/* // */

	check = w;
	check ^= SYS_T;

	for (i = 0; i < SYS_T*2; i++)
		check |= s[i] ^ s_cmp[i]; 

	check -= 1;
	check >>= 15;

	return check ^ 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x8a20, %rsp           # imm = 0x8A20
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0xd0, %rax
je 0x4616
movb (%rdx,%rax), %cl
movb %cl, 0x620(%rsp,%rax)
incq %rax
jmp 0x45ff
movl $0xd0, %eax
cmpq $0x400, %rax            # imm = 0x400
je 0x4630
movb $0x0, 0x620(%rsp,%rax)
incq %rax
jmp 0x461b
xorl %r15d, %r15d
leaq (%r14,%r15), %rsi
cmpq $0x100, %r15            # imm = 0x100
je 0x4658
movq %rsi, %rdi
callq 0x65c0
andl $0x1fff, %eax           # imm = 0x1FFF
movw %ax, (%rsp,%r15)
addq $0x2, %r15
jmp 0x4633
movq %rsp, %r14
movw $0x1, 0x100(%r14)
leaq 0x4a20(%rsp), %r15
movq %r15, %rdi
callq 0x1889
leaq 0x310(%rsp), %r12
leaq 0x620(%rsp), %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6410
leaq 0x510(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x19a4
leaq 0xa20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6145
xorl %eax, %eax
cmpq $0x400, %rax            # imm = 0x400
je 0x46cc
movb $0x0, (%rbx,%rax)
incq %rax
jmp 0x46bb
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq $0x2000, %r14           # imm = 0x2000
je 0x4705
movzwl 0xa20(%rsp,%r14,2), %edi
callq 0x4eb0
andl $0x1, %eax
movl %r14d, %ecx
andb $0x7, %cl
movl %eax, %edx
shlb %cl, %dl
addl %eax, %ebp
movl %r14d, %eax
shrl $0x3, %eax
orb %dl, (%rbx,%rax)
incq %r14
jmp 0x46d1
leaq 0x110(%rsp), %rdi
movq %rsp, %rsi
leaq 0x4a20(%rsp), %rdx
movq %rbx, %rcx
callq 0x6410
xorl $0x80, %ebp
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x4747
movzwl 0x110(%rsp,%rax,2), %ecx
xorw 0x310(%rsp,%rax,2), %cx
orl %ecx, %ebp
incq %rax
jmp 0x4728
negl %ebp
movzwl %bp, %eax
shrl $0xf, %eax
addq $0x8a20, %rsp           # imm = 0x8A20
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/die.c
// Function: die_usage
void die_usage(const char *name, const char *why, const char *usage) {
    cleanup();
    outs(name);
    outs(": usage: ");
    outs(name);
    outs(" ");
    outs(usage);
    outs("\n");
    outs(name);
    outs(": fatal: ");
    outs(why);
    outs(": ");
    outs(e_str(errno));
    outs("\n");
    flush();
    _exit(111);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x121c
movq %r15, %rdi
callq 0x4803
leaq 0x2c1e(%rip), %rdi      # 0x73a0
callq 0x4803
movq %r15, %rdi
callq 0x4803
leaq 0x2c12(%rip), %rdi      # 0x73a8
callq 0x4803
movq %r14, %rdi
callq 0x4803
leaq 0x2c00(%rip), %r14      # 0x73aa
movq %r14, %rdi
callq 0x4803
movq %r15, %rdi
callq 0x4803
leaq 0x2beb(%rip), %rdi      # 0x73ac
callq 0x4803
movq %rbx, %rdi
callq 0x4803
leaq 0x2bd2(%rip), %rdi      # 0x73a7
callq 0x4803
callq 0x1040
movl (%rax), %edi
callq 0x4940
movq %rax, %rdi
callq 0x4803
movq %r14, %rdi
callq 0x4803
callq 0x4851
pushq $0x6f
popq %rdi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/die.c
// Function: outs
static void outs(const char *x) {

    long long i;

    for(i = 0; x[i]; ++i) {
        if (buflen >= sizeof buf) flush();
        buf[buflen++] = x[i];
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x25232f(%rip), %r14    # 0x256b40
movb (%rbx), %al
testb %al, %al
je 0x4849
movq 0x252312(%rip), %rcx    # 0x256b30
cmpq $0x100, %rcx            # imm = 0x100
jb 0x4835
callq 0x4851
movb (%rbx), %al
movq 0x2522fb(%rip), %rcx    # 0x256b30
leaq 0x1(%rcx), %rdx
movq %rdx, 0x2522f0(%rip)    # 0x256b30
movb %al, (%rcx,%r14)
incq %rbx
jmp 0x4811
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/die.c
// Function: die_temp
void die_temp(const char *name, const char *why) {
    cleanup();
    outs(name);
    outs(": fatal: ");
    outs(why);
    if (errno) {
        outs(": ");
        outs(e_str(errno));
    }
    outs("\n");
    flush();
    _exit(111);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x121c
movq %r14, %rdi
callq 0x4803
leaq 0x2b0f(%rip), %rdi      # 0x73ac
callq 0x4803
movq %rbx, %rdi
callq 0x4803
callq 0x1040
cmpl $0x0, (%rax)
je 0x48d2
movq %rax, %rbx
leaq 0x2ae9(%rip), %rdi      # 0x73a7
callq 0x4803
movl (%rbx), %edi
callq 0x4940
movq %rax, %rdi
callq 0x4803
leaq 0x2ad1(%rip), %rdi      # 0x73aa
callq 0x4803
callq 0x4851
pushq $0x6f
popq %rdi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/die.c
// Function: die_perm
void die_perm(const char *name, const char *why) {
    cleanup();
    outs(name);
    outs(": fatal: ");
    outs(why);
    outs("\n");
    flush();
    _exit(100);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x121c
movq %r14, %rdi
callq 0x4803
leaq 0x2aa3(%rip), %rdi      # 0x73ac
callq 0x4803
movq %rbx, %rdi
callq 0x4803
leaq 0x2a8d(%rip), %rdi      # 0x73aa
callq 0x4803
callq 0x4851
pushq $0x64
popq %rdi
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/encrypt.c
// Function: syndrome
void syndrome(unsigned char *s, const unsigned char *pk, unsigned char *e)
{
	unsigned char b, row[SYS_N/8];
	const unsigned char *pk_ptr = pk;

	int i, j;

	for (i = 0; i < SYND_BYTES; i++)
		s[i] = 0;

	for (i = 0; i < PK_NROWS; i++)	
	{
		for (j = 0; j < SYS_N/8; j++) 
			row[j] = 0;

		for (j = 0; j < PK_ROW_BYTES; j++) 
			row[ SYS_N/8 - PK_ROW_BYTES + j ] = pk_ptr[j];

		row[i/8] |= 1 << (i%8);
		
		b = 0;
		for (j = 0; j < SYS_N/8; j++)
			b ^= row[j] & e[j];

		b ^= b >> 4;
		b ^= b >> 2;
		b ^= b >> 1;
		b &= 1;

		s[ i/8 ] |= (b << (i%8));

		pk_ptr += PK_ROW_BYTES;
	}
}

// Assembly:
xorl %eax, %eax
cmpq $0xd0, %rax
je 0x4c8b
movb $0x0, (%rdi,%rax)
incq %rax
jmp 0x4c7a
pushq %rbx
subq $0x380, %rsp            # imm = 0x380
xorl %eax, %eax
movl $0x1, %r8d
cmpl $0x680, %eax            # imm = 0x680
je 0x4d45
xorl %ecx, %ecx
cmpq $0x400, %rcx            # imm = 0x400
je 0x4cbb
movb $0x0, -0x80(%rsp,%rcx)
incq %rcx
jmp 0x4ca8
xorl %ecx, %ecx
cmpq $0x330, %rcx            # imm = 0x330
je 0x4cd4
movb (%rsi,%rcx), %r9b
movb %r9b, 0x50(%rsp,%rcx)
incq %rcx
jmp 0x4cbd
movl %eax, %ecx
andl $0x7, %ecx
movl %r8d, %r10d
shll %cl, %r10d
movl %eax, %r9d
shrl $0x3, %r9d
orb %r10b, -0x80(%rsp,%r9)
xorl %r11d, %r11d
xorl %r10d, %r10d
cmpq $0x400, %r11            # imm = 0x400
je 0x4d0b
movb (%rdx,%r11), %bl
andb -0x80(%rsp,%r11), %bl
xorb %bl, %r10b
incq %r11
jmp 0x4cf1
movl %r10d, %r11d
shrb $0x4, %r11b
xorb %r10b, %r11b
movl %r11d, %r10d
shrb $0x2, %r10b
xorb %r11b, %r10b
movl %r10d, %r11d
shrb %r11b
xorb %r10b, %r11b
andb $0x1, %r11b
movzbl %r11b, %r10d
shll %cl, %r10d
orb %r10b, (%rdi,%r9)
addq $0x330, %rsi            # imm = 0x330
incl %eax
jmp 0x4c9b
addq $0x380, %rsp            # imm = 0x380
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/fsyncfd.c
// Function: fsyncfd
int fsyncfd(int fd) {

    struct stat st;

    if (fstat(fd, &st) == 0 && S_ISREG(st.st_mode)) {
        if (fsync(fd) == -1) return -1;
    }
    return 0;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movl %edi, %ebx
movq %rsp, %rsi
callq 0x1110
testl %eax, %eax
jne 0x4e9e
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4e9e
movl %ebx, %edi
callq 0x10e0
cmpl $-0x1, %eax
je 0x4ea9
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x4ea0
nop
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/gf.c
// Function: gf_mul
gf gf_mul(gf in0, gf in1)
{
	int i;

	uint64_t tmp;
	uint64_t t0;
	uint64_t t1;
	uint64_t t;

	t0 = in0;
	t1 = in1;

	tmp = t0 * (t1 & 1);

	for (i = 1; i < GFBITS; i++)
		tmp ^= (t0 * (t1 & (1 << i)));

	/* // */

	t = tmp & 0x1FF0000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	t = tmp & 0x000E000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	return tmp & GFMASK;
}

// Assembly:
xorl %edx, %edx
testb $0x1, %sil
cmovnel %edi, %edx
pushq $0x1
popq %rax
movl %eax, %ecx
cmpl $0xd, %ecx
je 0x4ee3
movl %eax, %r8d
shll %cl, %r8d
andl %esi, %r8d
imull %edi, %r8d
xorl %r8d, %edx
incl %ecx
jmp 0x4eca
movl %edx, %eax
andl $0x1ff0000, %eax        # imm = 0x1FF0000
movl %eax, %ecx
shrl $0x9, %ecx
movl %eax, %esi
shrl $0xa, %esi
xorl %ecx, %esi
movl %eax, %ecx
shrl $0xc, %ecx
shrl $0xd, %eax
xorl %ecx, %eax
xorl %esi, %eax
xorl %edx, %eax
movl %eax, %ecx
andl $0xe000, %ecx           # imm = 0xE000
movl %ecx, %edx
shrl $0x9, %edx
movl %ecx, %esi
shrl $0xa, %esi
movl %ecx, %edi
shrl $0xc, %edi
xorl %edx, %edi
shrl $0xd, %ecx
andl $0x1fff, %eax           # imm = 0x1FFF
xorl %esi, %eax
xorl %edi, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/janmojzis[P]mcencrypt/gf.c
// Function: gf_mul2
uint64_t gf_mul2(gf a, gf b0, gf b1)
{
	int i;

	uint64_t tmp=0;
	uint64_t t0;
	uint64_t t1;
	uint64_t t;
	uint64_t mask = 0x0000000100000001;

	t0 = a;
	t1 = b1;
	t1 = (t1 << 32) | b0;
	
	for (i = 0; i < GFBITS; i++)
	{
		tmp ^= t0 * (t1 & mask);
		mask += mask;
	}

	/* // */

	t = tmp & 0x01FF000001FF0000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	t = tmp & 0x0000E0000000E000;
	tmp ^= (t >> 9) ^ (t >> 10) ^ (t >> 12) ^ (t >> 13);

	return tmp & 0x00001FFF00001FFF;
}

// Assembly:
movl %edi, %ecx
shlq $0x20, %rdx
movl %esi, %esi
orq %rdx, %rsi
movabsq $0x100000001, %rdx      # imm = 0x100000001
pushq $0xd
popq %rdi
xorl %eax, %eax
subl $0x1, %edi
jb 0x4f5d
movq %rdx, %r8
andq %rsi, %r8
imulq %rcx, %r8
xorq %r8, %rax
addq %rdx, %rdx
jmp 0x4f46
movabsq $0x1ff000001ff0000, %rcx # imm = 0x1FF000001FF0000
andq %rax, %rcx
movq %rcx, %rdx
shrq $0x9, %rdx
movq %rcx, %rsi
shrq $0xa, %rsi
xorq %rdx, %rsi
movq %rcx, %rdx
shrq $0xc, %rdx
shrq $0xd, %rcx
xorq %rdx, %rcx
xorq %rsi, %rcx
xorq %rax, %rcx
movabsq $0xe0000000e000, %rdx   # imm = 0xE0000000E000
andq %rcx, %rdx
movq %rdx, %rax
shrq $0x9, %rax
movq %rdx, %rsi
shrq $0xa, %rsi
movq %rdx, %rdi
shrq $0xc, %rdi
xorq %rax, %rdi
shrq $0xd, %rdx
movabsq $0x1fff00001fff, %rax   # imm = 0x1FFF00001FFF
andq %rcx, %rax
xorq %rsi, %rax
xorq %rdi, %rax
xorq %rdx, %rax
retq