LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/deepika9294[P]Threading-Library/many-one/queue.c
// Function: dequeue
dthread* dequeue(queue *t) {
    //check if the queue is empty
     if(t->count == 0 ) {
        return NULL;
     }
    dthread *td = t->head->td;
    t->head = t->head->next;
    t->count = t->count - 1;
    //check if the new head is null or not , if yes then change the tail
    if(t->head == NULL) {
        t->tail = NULL;
    }
    return(td);
}

// Assembly:
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1847
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
movq %rdx, (%rdi)
decl %ecx
movl %ecx, 0x10(%rdi)
testq %rdx, %rdx
jne 0x1845
movq $0x0, 0x8(%rdi)
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/deepika9294[P]Threading-Library/many-one/queue.c
// Function: show
void show(queue *t) {
    node *ptr;
    if(t->head == NULL) {
        printf("\nEmpty");
        return;
    }
    ptr = t->head;
    while(ptr != NULL) {
        printf("\nTID: %ld", ptr->td->tid);
        ptr = ptr->next;
    }
    printf("\nTOTAL: %d",t->count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x189a
movq %rdi, %rbx
leaq 0x7b6(%rip), %r14       # 0x201c
movq (%r15), %rax
movq (%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x1866
movl 0x10(%rbx), %esi
leaq 0x79d(%rip), %rdi       # 0x2026
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1080
leaq 0x774(%rip), %rdi       # 0x2015
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O3/deepika9294[P]Threading-Library/many-one/queue.c
// Function: get_node_by_tid
dthread* get_node_by_tid(queue *t, dthread_t tid) {
    node *temp;
    dthread *td;
    if(t->head == NULL) {
        return NULL;
    }
    temp = t->head;
    while(temp != NULL) {
        if(tid == temp->td->tid) {
            return temp->td;
        }
        else {
            temp = temp->next;
        }
    }
    return NULL;
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x18d3
pushq %rbp
movq %rsp, %rbp
movq (%rcx), %rax
cmpq %rsi, (%rax)
je 0x18d1
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x18be
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deepika9294[P]Threading-Library/many-one/test/methods.c
// Function: deadlock
void* deadlock(void *args) {
    
    int d  = dthread_join(t1[2], NULL);

    check = testing(d,EDEADLK);
    if(check == 0) {
        printf(RED "**FAILED**: Deadlock Join test\n" NONE);
    }
    else {
        printf(GREEN "**PASSED**: Deadlock join test\n" NONE);
    }
    return (void *)(intptr_t)(d);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x27f7(%rip), %rdi      # 0x4100
xorl %esi, %esi
callq 0x1677
movl %eax, %ebx
cmpl $0x23, %eax
leaq 0x742(%rip), %rax       # 0x205e
leaq 0x70e(%rip), %rdi       # 0x2031
cmoveq %rax, %rdi
xorl %eax, %eax
callq 0x1080
movslq %ebx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deepika9294[P]Threading-Library/many-one/test/methods.c
// Function: exit_control
void* exit_control(void *args) {
    counter++;
    dthread_exit(NULL);
    counter++;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incl 0x27ec(%rip)            # 0x4140
xorl %edi, %edi
callq 0x16de
incl 0x27df(%rip)            # 0x4140
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_23/c_remove_comments.c
// Function: main
int main(void)
{
  /**
   * This is multiline
   * block
   * comment.
  */

  char str[MAXSTR];
  char no_com_str[MAXSTR];

  get_str(str, MAXSTR);

  remove_comments(str, no_com_str);

  printf("%s", no_com_str);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x4e20, %rsp           # imm = 0x4E20
xorl %ebx, %ebx
callq 0x1040
cmpl $-0x1, %eax
je 0x1174
movb %al, (%rsp,%rbx)
incq %rbx
cmpq $0x270f, %rbx           # imm = 0x270F
jne 0x1156
movl $0x270f, %ebx           # imm = 0x270F
movb $0x0, (%rsp,%rbx)
movq %rsp, %rdi
leaq 0x2710(%rsp), %rbx
movq %rbx, %rsi
callq 0x11f1
leaq 0xe72(%rip), %rdi       # 0x2004
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x4e20, %rsp           # imm = 0x4E20
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_23/c_remove_comments.c
// Function: get_str
int get_str(char str[], int limit)
{
  int c, i = 0;

  while (i < limit - 1 && (c = getchar()) != EOF)
  {
    str[i++] = c;
  }
  str[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x2, %esi
jl 0x11dc
movl %esi, %ebp
decl %ebp
movl %ebp, %r15d
xorl %r14d, %r14d
callq 0x1040
cmpl $-0x1, %eax
je 0x11dc
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x11c3
movl %ebp, %r14d
movl %r14d, %eax
movb $0x0, (%rbx,%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_23/c_remove_comments.c
// Function: remove_comments
void remove_comments(char str[], char no_com_str[])
{
  int in_quote = FALSE;
  int line_comment = FALSE;
  int block_comment = FALSE;

  int i = 0, j = 0;
  while (str[i] != '\0')
  {
    if (!block_comment)
    {
      if (!in_quote && str[i] == '"')
    {
      in_quote = TRUE;
    }
    else if (in_quote && str[i] == '"')
    {
      in_quote = FALSE;
    }
    }

    if (!in_quote)
    {
      if (str[i] == '/' && str[i + 1] == '*' && !line_comment)
      {
        block_comment = TRUE;
      }

      if (str[i] == '*' && str[i + 1] == '/')
      {
        block_comment = FALSE;
        i += 2;
      }

      if (str[i] == '/' && str[i + 1] == '/')
      {
        line_comment = TRUE;
      }

      if (str[i] == '\n')
      {
        line_comment = FALSE;
      }

      if (line_comment || block_comment)
      {
        ++i;
      }
      else if (!line_comment || !block_comment)
      {
        no_com_str[j++] = str[i++];
      }
    }
    else
    {
      no_com_str[j++] = str[i++];
    }
  }

  no_com_str[j] = '\0';
}

// Assembly:
movb (%rdi), %r11b
xorl %eax, %eax
testb %r11b, %r11b
je 0x12ff
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl $0x1, %ecx
movq %rdi, %r14
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r10d, %r10d
xorl %r9d, %r9d
xorl %ebx, %ebx
testl %r10d, %r10d
je 0x124e
testl %ebx, %ebx
jne 0x12d4
cmpb $0x2a, %r11b
je 0x1278
movzbl %r11b, %r11d
cmpl $0x2f, %r11d
jne 0x1291
testl %r9d, %r9d
movl $0x1, %ebp
cmovnel %r10d, %ebp
cmpb $0x2a, 0x1(%r14)
cmovnel %r10d, %ebp
jmp 0x1294
testl %ebx, %ebx
sete %bpl
cmpb $0x22, %r11b
sete %r15b
testl %ebx, %ebx
je 0x126f
movl $0x1, %ebx
xorl %ebp, %ebp
cmpb $0x22, %r11b
je 0x1294
jmp 0x12d4
andb %r15b, %bpl
movzbl %bpl, %ebx
jmp 0x121f
leal 0x2(%r8), %r11d
cmpb $0x2f, 0x1(%r14)
cmovel %eax, %r10d
cmovnel %r8d, %r11d
movl %r10d, %ebp
movl %r11d, %r8d
jmp 0x1294
movl %r10d, %ebp
movslq %r8d, %r10
movb (%rdi,%r10), %r11b
cmpb $0x2f, %r11b
jne 0x12ab
cmpb $0x2f, 0x1(%rdi,%r10)
cmovel %ecx, %r9d
xorl %ebx, %ebx
cmpb $0xa, %r11b
movl %r9d, %r14d
cmovel %ebx, %r14d
movl %r14d, %r9d
orl %ebp, %r9d
movl $0x0, %r9d
movl $0x0, %r10d
je 0x12d4
movl %ebp, %r10d
movl %r14d, %r9d
jmp 0x12dd
movslq %edx, %r14
incl %edx
movb %r11b, (%rsi,%r14)
movslq %r8d, %r8
leaq (%rdi,%r8), %r14
incq %r14
incq %r8
movb (%r14), %r11b
testb %r11b, %r11b
jne 0x121a
movslq %edx, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
movb $0x0, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: nEnc
int nEnc(const uint8 *nonce, uint32 nonce_len, uint32 t_len){
	uint8 tmp[BLOCK]={0};

	memcpy(&tmp[BLOCK-nonce_len],nonce,nonce_len);
	tmp[0]=(uint8)((t_len*8)%(BLOCK*8)<<1);
	tmp[BLOCK-nonce_len-1] |= 0x01;
	Encryption(KeyLen, tmp, L);
	if(ADP==Seri){
		xor(L, TA, L); 
		mul2(L,L); /* L <- 2(E(Format(tau,N)) + TA)*/
	}
	mul3(L, Ls); 
	return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %rsi
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %r14
vmovaps %xmm0, (%r14)
movl $0x10, %eax
subl %ebp, %eax
leaq (%rsp,%rax), %rdi
movl %ebp, %edx
callq 0x1110
shlb $0x4, %bl
movb %bl, (%r14)
movl $0xf, %eax
subl %ebp, %eax
orb $0x1, (%rsp,%rax)
movq 0x3d24(%rip), %rbx      # 0x4fa0
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1100
movq 0x3d55(%rip), %rax      # 0x4fe8
vmovaps (%rax), %xmm0
vxorps (%rbx), %xmm0, %xmm0
vmovaps %xmm0, (%rbx)
movzbl (%rbx), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
movw $0x7fff, %cx            # imm = 0x7FFF
kmovd %ecx, %k1
vmovdqu8 0x1(%rbx), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe4, 0x1d29(%rip){1to4}, %xmm1, %xmm0 # 0x3000
vmovdqu8 %xmm0, (%rbx) {%k1}
shrl $0x7, %eax
movb 0xf(%rbx), %cl
addb %cl, %cl
leaq 0x1d34(%rip), %rdx      # 0x3020
xorb (%rax,%rdx), %cl
movb %cl, 0xf(%rbx)
movq 0x3cff(%rip), %rsi      # 0x4ff8
movq %rbx, %rdi
callq 0x130c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: mul2twice
static void mul2(uint8 *in, uint8 *out)
{
	int i, t = in[0] >> 7;
    for(i = 0; i < 15; i++)
        out[i] = (in[i] << 1) | (in[i + 1] >> 7);
    out[15] = (in[15] << 1) ^ cst_mul[t];
}

// Assembly:
movzbl (%rdi), %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb 0x1(%rdi,%rcx), %r8b
shrb $0x7, %r8b
addb %dl, %dl
orb %r8b, %dl
movb %dl, (%rsi,%rcx)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq $0xf, %rdx
jne 0x1f5c
shrl $0x7, %eax
movb 0xf(%rdi), %cl
addb %cl, %cl
leaq 0x1094(%rip), %rdx      # 0x3020
xorb (%rax,%rdx), %cl
movb %cl, 0xf(%rsi)
movzbl (%rsi), %eax
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %xmm0
movw $0x7fff, %cx            # imm = 0x7FFF
kmovd %ecx, %k1
vmovdqu8 0x1(%rsi), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe4, 0x1036(%rip){1to4}, %xmm1, %xmm0 # 0x3000
vmovdqu8 %xmm0, (%rsi) {%k1}
shrl $0x7, %eax
movb 0xf(%rsi), %cl
addb %cl, %cl
xorb (%rax,%rdx), %cl
movb %cl, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AFuncS
int AFuncS(
		  const uint8 *header,
		  uint32 h_len)
{
	uint32 i,j = 0;
	uint32 m, last;
	uint8 tmp[BLOCK], chain[BLOCK]={0}, Qt[BLOCK];

	last = h_len % BLOCK;
	if(last == 0) last = BLOCK;
	m = (h_len-last) / BLOCK; /*header = m blocks + last bytes*/

	/* CBC */
	for(i = 0; i < m; i++, j=j+BLOCK){
		xor(chain,header+j,chain);
		Encryption(KeyLen,chain,chain);
	}
	/* last block */
	ozp(last,header+j,tmp);
	xor(tmp,chain,chain);
	if(last != BLOCK ){/*partial block*/
		mul2(Q,Qt);
	}
	else{/*integral block*/
		mul2twice(Q,Qt);
	}
	xor(chain,Qt,chain);
	Encryption(KeyLen,chain,TA);
    return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
andl $0xf, %r15d
movl $0x10, %r12d
cmovnel %r15d, %r12d
subl %r12d, %ebp
cmpl $0x10, %ebp
jae 0x1e1e
xorl %r13d, %r13d
jmp 0x1e53
shrl $0x4, %ebp
xorl %r13d, %r13d
movq %rsp, %r14
vmovups (%rbx,%r13), %xmm0
vxorps (%rsp), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movq %r14, %rdx
callq 0x1100
addq $0x10, %r13
decl %ebp
jne 0x1e27
andl $-0x10, %r13d
addq %r13, %rbx
movl %r12d, %r14d
movl $0x10, %eax
subq %r14, %rax
xorl %edx, %edx
testl %r15d, %r15d
cmovneq %rax, %rdx
leaq (%rsp,%r14), %rdi
addq $0x10, %rdi
xorl %esi, %esi
callq 0x1030
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1110
testl %r15d, %r15d
je 0x1f03
movb $-0x80, 0x10(%rsp,%r14)
vmovaps (%rsp), %xmm0
vxorps 0x10(%rsp), %xmm0, %xmm0
vmovaps %xmm0, (%rsp)
movq 0x3115(%rip), %rax      # 0x4fc0
movzbl (%rax), %ecx
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %xmm0
movw $0x7fff, %dx            # imm = 0x7FFF
kmovd %edx, %k1
vmovdqu8 0x1(%rax), %xmm1 {%k1} {z}
vpalignr $0xf, %xmm0, %xmm1, %xmm0 # xmm0 = xmm0[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpsrlw $0x7, %xmm1, %xmm1
vpaddw %xmm0, %xmm0, %xmm0
vpternlogd $0xe4, 0x111d(%rip){1to4}, %xmm1, %xmm0 # 0x3000
vmovdqu8 %xmm0, 0x20(%rsp) {%k1}
shrl $0x7, %ecx
movb 0xf(%rax), %al
addb %al, %al
leaq 0x1126(%rip), %rdx      # 0x3020
xorb (%rcx,%rdx), %al
movb %al, 0x2f(%rsp)
jmp 0x1f24
vmovdqa (%rsp), %xmm0
vpxor 0x10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
movq 0x30a6(%rip), %rdi      # 0x4fc0
leaq 0x20(%rsp), %rsi
callq 0x1f57
vmovaps 0x20(%rsp), %xmm0
movq %rsp, %rsi
vxorps (%rsi), %xmm0, %xmm0
vmovaps %xmm0, (%rsi)
movq 0x30ac(%rip), %rdx      # 0x4fe8
movl $0x100, %edi            # imm = 0x100
callq 0x1100
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AE_Encrypt
int AE_Encrypt(
	      const uint8 *nonce,
		  uint32 nonce_len,
		  const uint8 *plaintext,
		  uint32 pl_len,
		  const uint8 *header,
		  uint32 h_len,
		  uint32 t_len,
		  uint8 *ciphertext,
		  uint8 *tag)
{
	if(ADP==Para)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFunc(header,h_len);
		}
		EFunc(nonce,nonce_len,plaintext,pl_len,t_len,ciphertext);
		xorp(t_len,TE,TA,tag);
	}
	else if(ADP==Seri)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFuncS(header,h_len);
		}
			EFunc(nonce,nonce_len,plaintext,pl_len,t_len,ciphertext);
			memcpy(tag,TE,t_len);
	}
	return SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
movq 0x48(%rsp), %r12
movl 0x40(%rsp), %r14d
testl %r9d, %r9d
je 0x2011
movq %r8, %rdi
movl %r9d, %esi
callq 0x10e0
jmp 0x2020
vxorps %xmm0, %xmm0, %xmm0
movq 0x2fcc(%rip), %rax      # 0x4fe8
vmovaps %xmm0, (%rax)
movq %rbx, %rdi
movl %r13d, %esi
movq %r15, %rdx
movl %ebp, %ecx
movl %r14d, %r8d
movq %r12, %r9
callq 0x1070
movl %r14d, %edx
movq 0x2fa0(%rip), %rsi      # 0x4fe0
movq 0x50(%rsp), %rdi
callq 0x1110
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aes256otrsv3/ref/OTR.c
// Function: AE_Decrypt
int AE_Decrypt(
	      const uint8 *nonce,
		  uint32 nonce_len,
		  const uint8 *ciphertext,
		  uint32 ci_len,
		  const uint8 *header,
		  uint32 h_len,
		  uint32 t_len,
  		  const uint8 *tag,
		  uint8 *plaintext)
{
	uint32 i;
	uint8 loctag[BLOCK];

	if(ADP==Para)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFunc(header,h_len);
		}
			DFunc(nonce,nonce_len,ciphertext,ci_len,t_len,plaintext);
			xorp(t_len,TE,TA,loctag);
	}
	else if(ADP==Seri)
	{
		if(h_len==0){
			memset(TA,0,BLOCK);
		}
		else{
			AFuncS(header,h_len);
		}
			DFunc(nonce,nonce_len,ciphertext,ci_len,t_len,plaintext);
			memcpy(loctag,TE,t_len);
	}

	if(memcmp(loctag,tag,t_len)!=0){/*verfication failure*/
		for(i=0; i<ci_len; i++)plaintext[i] = 0;/* zeroing wrong plaintext*/
		return TAG_UNMATCH;
	}
	return TAG_MATCH;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r14
movq 0x60(%rsp), %r15
movl 0x50(%rsp), %ebp
testl %r9d, %r9d
je 0x208f
movq %r8, %rdi
movl %r9d, %esi
callq 0x10e0
jmp 0x209e
vxorps %xmm0, %xmm0, %xmm0
movq 0x2f4e(%rip), %rax      # 0x4fe8
vmovaps %xmm0, (%rax)
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
movl %ebx, %ecx
movl %ebp, %r8d
movq %r15, %r9
callq 0x1080
movl %ebp, %r14d
movq 0x2f22(%rip), %rsi      # 0x4fe0
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0x1110
movq %r12, %rdi
movq 0x58(%rsp), %rsi
movq %r14, %rdx
callq 0x10c0
testl %eax, %eax
je 0x20f7
movl $0x1, %ebp
testl %ebx, %ebx
je 0x20f9
movl %ebx, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1030
jmp 0x20f9
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/common.c
// Function: log_file_loading_error
int log_file_loading_error(char *file_description, char *file_name) {
    fprintf(stderr, "Unable to open %s %s.\n", file_description, file_name);
    fprintf(stderr, "Errno: %d\n", errno);
    char error[MAX_STRING_LENGTH];
    STRERROR(errno, error, MAX_STRING_LENGTH);
    fprintf(stderr, "Error description: %s\n", error);
    return errno;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
movq %rsi, %rcx
movq %rdi, %rdx
movq 0x5676(%rip), %r15      # 0x6ff8
movq (%r15), %rdi
leaq 0x3630(%rip), %rsi      # 0x4fbc
xorl %eax, %eax
callq 0x1170
movq (%r15), %rbx
callq 0x1050
movq %rax, %r14
movl (%rax), %edx
leaq 0x362c(%rip), %rsi      # 0x4fd3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1170
movl (%r14), %edi
movq %rsp, %rbx
movl $0x3e8, %edx            # imm = 0x3E8
movq %rbx, %rsi
callq 0x10c0
movq (%r15), %rdi
leaq 0x3610(%rip), %rsi      # 0x4fde
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1170
movl (%r14), %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/glove.c
// Function: load_init_file
int load_init_file(char *file_name, real *array, long long array_size) {
    FILE *fin;
    long long a;
    fin = fopen(file_name, "rb");
    if (fin == NULL) {
        log_file_loading_error("init file", file_name);
        return -1;
    }
    for (a = 0; a < array_size; a++) {
        if (feof(fin)) {
            fprintf(stderr, "EOF reached before data fully loaded in %s.\n", file_name);
            fclose(fin);
            return -1;
        }
        fread(&array[a], sizeof(real), 1, fin);
    }
    fclose(fin);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x258c(%rip), %rsi      # 0x4080
callq 0x1200
testq %rax, %rax
je 0x1b3c
movq %rax, %r14
testq %r15, %r15
jle 0x1b30
movq %r14, %rdi
callq 0x1180
testl %eax, %eax
jne 0x1b5c
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0x10a0
addq $0x8, %r12
decq %r15
jne 0x1b06
movq %r14, %rdi
callq 0x10e0
xorl %eax, %eax
jmp 0x1b50
leaq 0x2540(%rip), %rdi      # 0x4083
movq %rbx, %rsi
callq 0x1969
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x5495(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x2520(%rip), %rsi      # 0x408d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1170
movq %r14, %rdi
callq 0x10e0
jmp 0x1b4b
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/common.c
// Function: get_word
int get_word(char *word, FILE *fin) {
    int i = 0, ch;
    for ( ; ; ) {
        ch = fgetc(fin);
        if (ch == '\r') continue;
        if (i == 0 && ((ch == '\n') || (ch == EOF))) {
            word[i] = 0;
            return 1;
        }
        if (i == 0 && ((ch == ' ') || (ch == '\t'))) continue; // skip leading space
        if ((ch == EOF) || (ch == ' ') || (ch == '\t') || (ch == '\n')) {
            if (ch == '\n') ungetc(ch, fin); // return the newline next time as document ender
            break;
        }
        if (i < MAX_STRING_LENGTH - 1)
          word[i++] = ch; // don't allow words to exceed MAX_STRING_LENGTH
    }
    word[i] = 0; //null terminate
    // avoid truncation destroying a multibyte UTF-8 char except if only thing on line (so the i > x tests won't overwrite word[0])
    // see https://en.wikipedia.org/wiki/UTF-8#Description
    if (i == MAX_STRING_LENGTH - 1 && (word[i-1] & 0x80) == 0x80) {
        if ((word[i-1] & 0xC0) == 0xC0) {
            word[i-1] = '\0';
        } else if (i > 2 && (word[i-2] & 0xE0) == 0xE0) {
            word[i-2] = '\0';
        } else if (i > 3 && (word[i-3] & 0xF8) == 0xF0) {
            word[i-3] = '\0';
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %ecx, %ecx
movl %ecx, %ebp
movq %r14, %rdi
callq 0x1110
cmpl $0xd, %eax
je 0x3401
testl %ebp, %ebp
je 0x3441
cmpl $0x9, %eax
jg 0x3423
cmpl $-0x1, %eax
je 0x3472
cmpl $0x9, %eax
jne 0x342d
jmp 0x3472
cmpl $0x20, %eax
je 0x3472
cmpl $0xa, %eax
je 0x3465
cmpl $0x3e6, %ebp            # imm = 0x3E6
jg 0x3401
movslq %ebp, %rcx
incl %ebp
movb %al, (%rbx,%rcx)
movl %ebp, %ecx
jmp 0x33ff
movl $0x0, %ecx
cmpl $0x9, %eax
jg 0x3454
je 0x33ff
cmpl $-0x1, %eax
jne 0x3435
jmp 0x345e
cmpl $0x20, %eax
je 0x33ff
cmpl $0xa, %eax
jne 0x3435
movl $0x1, %eax
jmp 0x34c6
movl $0xa, %edi
movq %r14, %rsi
callq 0x11c0
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
cmpl $0x3e7, %ebp            # imm = 0x3E7
jne 0x34c9
movb 0x3e6(%rbx), %cl
testb %cl, %cl
jns 0x34c9
xorl %eax, %eax
cmpb $-0x41, %cl
jbe 0x349d
addq $0x3e6, %rbx            # imm = 0x3E6
jmp 0x34c6
cmpb $-0x21, 0x3e5(%rbx)
jbe 0x34af
addq $0x3e5, %rbx            # imm = 0x3E5
jmp 0x34c6
movb 0x3e4(%rbx), %cl
andb $-0x8, %cl
xorl %eax, %eax
cmpb $-0x10, %cl
jne 0x34c9
addq $0x3e4, %rbx            # imm = 0x3E4
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/common.c
// Function: find_arg
int find_arg(char *str, int argc, char **argv) {
    int i;
    for (i = 1; i < argc; i++) {
        if (!scmp(str, argv[i])) {
            if (i == argc - 1) {
                printf("No argument given for %s\n", str);
                exit(1);
            }
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %esi
jl 0x3533
movq %rdi, %rcx
movb (%rdi), %r8b
movl %esi, %r9d
leaq 0x1(%rdi), %r10
movl $0x1, %edi
movq (%rdx,%rdi,8), %r11
testb %r8b, %r8b
je 0x3516
movq %r10, %r14
movl %r8d, %ebx
cmpb (%r11), %bl
jne 0x3511
incq %r11
movb (%r14), %bl
incq %r14
testb %bl, %bl
jne 0x34fd
xorl %ebx, %ebx
movsbl %bl, %ebx
jmp 0x3518
xorl %ebx, %ebx
movsbl (%r11), %r11d
cmpl %r11d, %ebx
je 0x352b
incq %rdi
cmpq %r9, %rdi
jne 0x34ee
jmp 0x3533
decl %esi
movl %edi, %eax
cmpl %edi, %esi
je 0x353b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a60(%rip), %rdi      # 0x4fa2
movq %rcx, %rsi
xorl %eax, %eax
callq 0x10f0
movl $0x1, %edi
callq 0x1230
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/common.c
// Function: free_table
void free_table(HASHREC **ht) {
    int i;
    HASHREC* current;
    HASHREC* tmp;
    for (i = 0; i < TSIZE; i++) {
        current = ht[i];
        while (current != NULL) {
            tmp = current;
            current = current->next;
            free(tmp->word);
            free(tmp);
        }
    }
    free(ht);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx,%r15,8), %r14
testq %r14, %r14
je 0x3589
movq (%r14), %rdi
movq 0x10(%r14), %r12
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r12, %r14
testq %r12, %r12
jne 0x356d
incq %r15
cmpq $0x100000, %r15         # imm = 0x100000
jne 0x3564
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/stanfordnlp[P]GloVe/src/common.c
// Function: free_fid
void free_fid(FILE **fid, const int num) {
    int i;
    for(i = 0; i < num; i++) {
        if(fid[i] != NULL)
            fclose(fid[i]);
    }
    free(fid);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x35d0
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x35c8
callq 0x10e0
incq %r15
cmpq %r15, %r14
jne 0x35ba
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/src/test_gauss_elimination.c
// Function: main
int
main(int argc VL_UNUSED, char**argv VL_UNUSED)
{
  double A [] = { 1, 12, 3, 4 };
  double b [] = { 1, -2 } ;
  double x [2] ;
  double c [2] ;
  int i ;

  vl_solve_linear_system_2 (x, A, b) ;

  c[0] = A[0] * x[0] + A[2] * x[1] ;
  c[1] = A[1] * x[0] + A[3] * x[1] ;

  for (i = 0 ; i < 2 ; ++i) {
    VL_PRINTF("[A x]_%-4d = %4g, b_%-4d = %4g\n", i+1, c[i], i+1, b[i]) ;
  }

  return 0 ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movaps 0xec4(%rip), %xmm0      # 0x2020
leaq 0x30(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps 0xea3(%rip), %xmm0      # 0x2010
movaps %xmm0, (%r14)
movaps 0xeb8(%rip), %xmm0      # 0x2030
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1040
movapd (%r15), %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
mulpd 0x10(%r14), %xmm0
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd (%r14), %xmm1
addpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
callq 0x1030
movq %rax, %rcx
movsd (%rbx), %xmm1
leaq 0xe75(%rip), %r14       # 0x2040
movq %r14, %rdi
movl $0x1, %esi
movaps (%rsp), %xmm0
movl $0x1, %edx
movb $0x2, %al
callq *%rcx
callq 0x1030
movq %rax, %rcx
movaps (%rsp), %xmm0
movhlps %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movsd 0x8(%rbx), %xmm1
movq %r14, %rdi
movl $0x2, %esi
movl $0x2, %edx
movb $0x2, %al
callq *%rcx
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::KeccakF(unsigned int, int, unsigned int)
KeccakF::KeccakF(unsigned int aWidth, int aStartRoundIndex, unsigned int aNrRounds)
{
    width = aWidth;
    initializeNominalNumberOfRounds();
    laneSize = width/25;
    nrRounds = aNrRounds;
    startRoundIndex = aStartRoundIndex;
    mask = (LaneValue(~0)) >> (64-laneSize);
    initializeRhoOffsets();
    initializeRoundConstants();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rdi, %rbx
movq 0x95de(%rip), %rax      # 0xefa0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x20(%rdi)
vmovups %ymm0, 0x30(%rdi)
movl %esi, 0x8(%rdi)
vzeroupper
callq 0x55c0
movl 0x8(%rbx), %eax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x23, %rax
movl %eax, 0xc(%rbx)
movl %r15d, 0x18(%rbx)
movl %ebp, 0x14(%rbx)
movq $-0x1, %rcx
bzhiq %rax, %rcx, %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x5050
movq %rbx, %rdi
callq 0x56a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5a41
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x5060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5760
movq %r15, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::initializeNominalNumberOfRounds()
void KeccakF::initializeNominalNumberOfRounds()
{
    switch(width) {
    case 25:
        nominalNrRounds = 12;
        break;
    case 50:
        nominalNrRounds = 14;
        break;
    case 100:
        nominalNrRounds = 16;
        break;
    case 200:
        nominalNrRounds = 18;
        break;
    case 400:
        nominalNrRounds = 20;
        break;
    case 800:
        nominalNrRounds = 22;
        break;
    case 1600:
        nominalNrRounds = 24;
        break;
    default:
        throw(KeccakException("The width must be 25 times a power of two between 1 and 64."));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x8(%rdi), %eax
cmpl $0xc7, %eax
jle 0x5a84
cmpl $0x31f, %eax            # imm = 0x31F
jg 0x5a9a
cmpl $0xc8, %eax
je 0x5abd
cmpl $0x190, %eax            # imm = 0x190
jne 0x5ad7
movl $0x14, %eax
jmp 0x5ac9
cmpl $0x19, %eax
je 0x5ab6
cmpl $0x32, %eax
je 0x5aaf
cmpl $0x64, %eax
jne 0x5ad7
movl $0x10, %eax
jmp 0x5ac9
cmpl $0x320, %eax            # imm = 0x320
je 0x5ac4
cmpl $0x640, %eax            # imm = 0x640
jne 0x5ad7
movl $0x18, %eax
jmp 0x5ac9
movl $0xe, %eax
jmp 0x5ac9
movl $0xc, %eax
jmp 0x5ac9
movl $0x12, %eax
jmp 0x5ac9
movl $0x16, %eax
movl %eax, 0x10(%rdi)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x55a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5580(%rip), %rsi      # 0xb074
leaq 0x55b4(%rip), %rdx      # 0xb0af
leaq 0x8(%rsp), %rdi
callq 0x5160
movq %rbx, %rax
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x5170
xorl %ebp, %ebp
movq 0x9490(%rip), %rsi      # 0xefc0
movq 0x9481(%rip), %rdx      # 0xefb8
movq %rbx, %rdi
callq 0x5270
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5b59
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5060
testb %bpl, %bpl
jne 0x5b63
jmp 0x5b6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5380
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::initializeRoundConstants()
void KeccakF::initializeRoundConstants()
{
    roundConstants.clear();
    UINT8 LFSRstate = 0x01;
    for(unsigned int i=0; i<255; i++) {
        LaneValue c = 0;
        for(unsigned int j=0; j<7; j++) {
            unsigned int bitPosition = (1<<j)-1; //2^j-1
            if (LFSR86540(LFSRstate))
                c ^= (LaneValue)1<<bitPosition;
        }
        roundConstants.push_back(c & mask);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rax
cmpq %rax, 0x40(%rdi)
je 0x5bfa
movq %rax, 0x40(%rbx)
leaq 0x38(%rbx), %r14
movb $0x1, %r15b
xorl %r12d, %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x1, %r13d
xorl %ecx, %ecx
xorl %eax, %eax
movl %r15d, %edx
leal (%rdx,%rdx), %esi
movzbl %sil, %edi
xorb $0x71, %sil
testb %r15b, %r15b
movzbl %sil, %r15d
cmovnsl %edi, %r15d
testb $0x1, %dl
shlxl %ecx, %ebp, %edx
notb %dl
shlxq %rdx, %r13, %rdx
movl $0x0, %esi
cmovneq %rdx, %rsi
xorq %rsi, %rax
incl %ecx
cmpl $0x7, %ecx
jne 0x5c13
andq 0x50(%rbx), %rax
movq %rax, (%rsp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x5c6d
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x40(%rbx)
jmp 0x5c78
movq %r14, %rdi
movq %rsp, %rdx
callq 0x5100
incl %r12d
cmpl $0xff, %r12d
jne 0x5c0f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::KeccakF(unsigned int)
KeccakF::KeccakF(unsigned int aWidth)
{
    width = aWidth;
    initializeNominalNumberOfRounds();
    laneSize = width/25;
    nrRounds = nominalNrRounds;
    startRoundIndex = 0;
    mask = (LaneValue(~0)) >> (64-laneSize);
    initializeRhoOffsets();
    initializeRoundConstants();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x92fd(%rip), %rax      # 0xefa0
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x20(%rdi), %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x20(%rdi)
vmovups %ymm0, 0x30(%rdi)
movl %esi, 0x8(%rdi)
vzeroupper
callq 0x55c0
movl 0x8(%rbx), %eax
movl 0x10(%rbx), %ecx
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
shrq $0x23, %rax
movl %eax, 0xc(%rbx)
movl %ecx, 0x18(%rbx)
movl $0x0, 0x14(%rbx)
movq $-0x1, %rcx
bzhiq %rax, %rcx, %rax
movq %rax, 0x50(%rbx)
movq %rbx, %rdi
callq 0x5050
movq %rbx, %rdi
callq 0x56a0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5d23
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x5060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5775
movq %r15, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::fromBytesToLanes(unsigned char const*, std::vector<unsigned long long, std::allocator<unsigned long long>>&) const
void KeccakF::fromBytesToLanes(const UINT8 *in, vector<LaneValue>& out) const
{
    out.resize(25);
    if ((laneSize == 1) || (laneSize == 2) || (laneSize == 4) || (laneSize == 8)) {
        for(unsigned int i=0; i<25; i++)
            out[i] = (in[i*laneSize/8] >> ((i*laneSize) % 8)) & mask;
    }
    else if ((laneSize == 16) || (laneSize == 32) || (laneSize == 64)) {
        for(unsigned int i=0; i<25; i++) {
            out[i] = 0;
            for(unsigned int j=0; j<(laneSize/8); j++)
                out[i] |= LaneValue((UINT8)(in[i*laneSize/8+j])) << (8*j);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x19, %esi
movq %rdx, %rdi
callq 0x5280
movl 0xc(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x3f, %ecx
ja 0x5f2c
movl $0x8b, %edx
btq %rcx, %rdx
jae 0x5ecd
movq (%r15), %rcx
xorl %edx, %edx
xorl %esi, %esi
movl %edx, %edi
shrl $0x3, %edi
movzbl (%rbx,%rdi), %edi
movl %edx, %r8d
andb $0x7, %r8b
shrxl %r8d, %edi, %edi
andl 0x50(%r14), %edi
movq %rdi, (%rcx,%rsi,8)
incq %rsi
addl %eax, %edx
cmpq $0x19, %rsi
jne 0x5ea3
jmp 0x5f2c
movabsq $-0x7fffffff7fff8000, %rdx # imm = 0x8000000080008000
btq %rcx, %rdx
jae 0x5f2c
movq (%r15), %rcx
movl %eax, %edx
shrl $0x3, %edx
xorl %esi, %esi
xorl %edi, %edi
movl %esi, %r8d
shrl $0x3, %r8d
addq %rbx, %r8
movq $0x0, (%rcx,%rdi,8)
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %r11d, %r11d
movzbl (%r8,%r10), %r14d
shlxq %r9, %r14, %r14
orq %r14, %r11
movq %r11, (%rcx,%rdi,8)
incq %r10
addq $0x8, %r9
cmpq %r10, %rdx
jne 0x5f04
incq %rdi
addl %eax, %esi
cmpq $0x19, %rdi
jne 0x5ee9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::fromLanesToBytes(std::vector<unsigned long long, std::allocator<unsigned long long>> const&, unsigned char*) const
void KeccakF::fromLanesToBytes(const vector<LaneValue>& in, UINT8 *out) const
{
    if ((laneSize == 1) || (laneSize == 2) || (laneSize == 4) || (laneSize == 8)) {
        for(unsigned int i=0; i<(25*laneSize+7)/8; i++)
            out[i] = 0;
        for(unsigned int i=0; i<25; i++)
            out[i*laneSize/8] |= in[i] << ((i*laneSize) % 8);
    }
    else if ((laneSize == 16) || (laneSize == 32) || (laneSize == 64)) {
        for(unsigned int i=0; i<25; i++)
            for(unsigned int j=0; j<(laneSize/8); j++)
                out[i*(laneSize/8)+j] = (UINT8)((in[i] >> (8*j)) & 0xFF);
    }
}

// Assembly:
movl 0xc(%rdi), %ecx
leal -0x1(%rcx), %eax
cmpl $0x3f, %eax
ja 0x5fed
movl $0x8b, %r8d
btq %rax, %r8
jae 0x5f97
xorl %eax, %eax
movb $0x0, (%rdx,%rax)
incq %rax
movl 0xc(%rdi), %ecx
leal (%rcx,%rcx,4), %ecx
leal (%rcx,%rcx,4), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
cmpq %rcx, %rax
jb 0x5f4f
xorl %eax, %eax
movq (%rsi), %rcx
movl 0xc(%rdi), %r8d
imull %eax, %r8d
movl %r8d, %r9d
andb $0x7, %r9b
shlxq %r9, (%rcx,%rax,8), %rcx
shrl $0x3, %r8d
orb %cl, (%rdx,%r8)
incq %rax
cmpq $0x19, %rax
jne 0x5f6c
jmp 0x5fed
movabsq $-0x7fffffff7fff8000, %r8 # imm = 0x8000000080008000
btq %rax, %r8
jae 0x5fed
xorl %eax, %eax
cmpl $0x8, %ecx
jb 0x5fe4
shrl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movl %ecx, %r10d
movq (%rsi), %rcx
shrxq %r8, (%rcx,%rax,8), %rcx
imull %eax, %r10d
addl %r9d, %r10d
movb %cl, (%rdx,%r10)
incq %r9
movl 0xc(%rdi), %ecx
movl %ecx, %r10d
shrl $0x3, %r10d
addq $0x8, %r8
cmpq %r10, %r9
jb 0x5fba
incq %rax
cmpq $0x19, %rax
jne 0x5fa9
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::operator()(unsigned char*) const
void KeccakF::operator()(UINT8 * state) const
{
    vector<LaneValue> A(25);
    fromBytesToLanes(state, A);
    forward(A);
    fromLanesToBytes(A, state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xc8, %edi
callq 0x5210
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xc8(%rax), %rcx
movq %rcx, 0x10(%rdx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
vmovups %ymm0, 0x20(%rax)
vmovups %ymm0, 0x40(%rax)
vmovups %ymm0, 0x60(%rax)
vmovups %ymm0, 0x80(%rax)
vmovups %ymm0, 0xa0(%rax)
movq $0x0, 0xc0(%rax)
movq %rcx, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
vzeroupper
callq 0x54c0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5130
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5520
movq (%r15), %rdi
testq %rdi, %rdi
je 0x6093
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x60b7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::inverse(unsigned char*) const
void KeccakF::inverse(UINT8 * state) const
{
    vector<LaneValue> A(25);
    fromBytesToLanes(state, A);
    inverse(A);
    fromLanesToBytes(A, state);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0xc8, %edi
callq 0x5210
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xc8(%rax), %rcx
movq %rcx, 0x10(%rdx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rax)
vmovups %ymm0, 0x20(%rax)
vmovups %ymm0, 0x40(%rax)
vmovups %ymm0, 0x60(%rax)
vmovups %ymm0, 0x80(%rax)
vmovups %ymm0, 0xa0(%rax)
movq $0x0, 0xc0(%rax)
movq %rcx, 0x8(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
vzeroupper
callq 0x54c0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x5370
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5520
movq (%r15), %rdi
testq %rdi, %rdi
je 0x6165
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6189
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x5060
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::getDescription[abi:cxx11]() const
string KeccakF::getDescription() const
{
    stringstream a;
    if ((nrRounds == nominalNrRounds) && (startRoundIndex == 0))
        a << "Keccak-f[" << dec << width;
    else if ((startRoundIndex + nrRounds) == nominalNrRounds)
        a << "Keccak-p[" << dec << width << ", " << nrRounds;
    else {
        a << "Keccak-f[" << dec << width;
        a << ", " << dec << nrRounds << " rounds " << startRoundIndex << "-" << (startRoundIndex+nrRounds-1);
    }
    a << "]";
    return a.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5720
movl 0x18(%r14), %edx
movl 0x10(%r14), %eax
movl 0x14(%r14), %ecx
movl %edx, %esi
xorl %eax, %esi
orl %ecx, %esi
jne 0x61fb
leaq 0x18(%rsp), %r15
leaq 0x4ee2(%rip), %rsi      # 0xb0b0
movl $0x9, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x8(%r14), %eax
jmp 0x6311
addl %edx, %ecx
leaq 0x18(%rsp), %r15
cmpl %eax, %ecx
jne 0x625d
leaq 0x4ead(%rip), %rsi      # 0xb0ba
movl $0x9, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x56d0
movq %rax, %r15
leaq 0x4e7d(%rip), %rsi      # 0xb0c4
movl $0x2, %edx
movq %rax, %rdi
callq 0x5250
movl 0x18(%r14), %eax
jmp 0x6311
leaq 0x4e4c(%rip), %rsi      # 0xb0b0
movl $0x9, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x56d0
leaq 0x4e29(%rip), %rsi      # 0xb0c4
movl $0x2, %edx
movq %r15, %rdi
callq 0x5250
movq 0x18(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x30(%rsp,%rax)
movl 0x18(%r14), %esi
movq %r15, %rdi
callq 0x56d0
movq %rax, %r15
leaq 0x4df2(%rip), %rsi      # 0xb0c7
movl $0x8, %edx
movq %rax, %rdi
callq 0x5250
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x55f0
movq %rax, %r15
leaq 0x4de1(%rip), %rsi      # 0xb0d9
movl $0x1, %edx
movq %rax, %rdi
callq 0x5250
movl 0x14(%r14), %eax
movl 0x18(%r14), %ecx
addl %ecx, %eax
decl %eax
movl %eax, %esi
movq %r15, %rdi
callq 0x56d0
leaq 0x18(%rsp), %rdi
leaq 0x4da9(%rip), %rsi      # 0xb0d0
movl $0x1, %edx
callq 0x5250
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x8c8b(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8c5a(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::getName[abi:cxx11]() const
string KeccakF::getName() const
{
    stringstream a;
    a << "KeccakF-" << dec << width << "-" << nrRounds;
    if (startRoundIndex != 0)
        a << "-" << startRoundIndex;
    return a.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x5720
leaq 0x10(%rsp), %r15
leaq 0x4d14(%rip), %rsi      # 0xb0d2
movl $0x8, %edx
movq %r15, %rdi
callq 0x5250
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x28(%rsp,%rax)
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x56d0
movq %rax, %r12
leaq 0x4ce1(%rip), %rsi      # 0xb0d9
movl $0x1, %edx
movq %rax, %rdi
callq 0x5250
movl 0x18(%r14), %esi
movq %r12, %rdi
callq 0x56d0
cmpl $0x0, 0x14(%r14)
je 0x6438
leaq 0x4cba(%rip), %rsi      # 0xb0d9
movl $0x1, %edx
movq %r15, %rdi
callq 0x5250
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x55f0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x8b84(%rip), %rsi      # 0xefd0
movq %rsp, %rdi
callq 0x53b0
leaq 0x80(%rsp), %rdi
callq 0x55b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8b53(%rip), %rsi      # 0xefd0
movq %rsp, %rdi
callq 0x53b0
leaq 0x80(%rsp), %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.cpp
// Function: KeccakF::buildBitName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
string KeccakF::buildBitName(const string& prefixSymbol, unsigned int laneSize, unsigned int z)
{
    stringstream s;
    s << prefixSymbol;
    if (laneSize > 1) {
        s.fill('0');
        if (laneSize <= 10)
            s.width(1);
        else if (laneSize <= 100)
            s.width(2);
        s << z;
    }
    return s.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5720
leaq 0x18(%rsp), %r14
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x5250
cmpl $0x2, %r15d
jb 0x6665
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %r12
addq $0x8, %r12
cmpb $0x0, 0xe1(%r12)
jne 0x662e
movq %r12, %rdi
movl $0x20, %esi
callq 0x5030
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
movl $0x1, %eax
cmpl $0xb, %r15d
jb 0x664d
movl $0x2, %eax
cmpl $0x64, %r15d
ja 0x665b
movq 0x8(%rsp), %rcx
movq -0x18(%rcx), %rcx
movq %rax, 0x18(%rsp,%rcx)
movl %ebp, %esi
movq %r14, %rdi
callq 0x56d0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x54b0
movq 0x8957(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8923(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x53b0
leaq 0x88(%rsp), %rdi
callq 0x55b0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/ref/Keccak-f.h
// Function: void KeccakF::round<unsigned long long>(std::vector<unsigned long long, std::allocator<unsigned long long>>&, int) const
void KeccakF::round(vector<Lane>& state, int roundIndex) const
{
    theta(state);
    rho(state);
    pi(state);
    chi(state);
    iota(state, roundIndex);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x50c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x51d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5690
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52d0
movslq %ebp, %rax
imulq $-0x7f7f7f7f, %rax, %rcx # imm = 0x80808081
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x7, %ecx
addl %edx, %ecx
movl %ecx, %edx
shll $0x8, %edx
subl %edx, %ecx
leal (%rax,%rcx), %edx
addl %ecx, %eax
addl $0xff, %eax
cmpl $0xffffff01, %edx       # imm = 0xFFFFFF01
cmovbl %edx, %eax
movq 0x38(%r14), %rcx
movq (%rcx,%rax,8), %rax
movq (%rbx), %rcx
xorq %rax, (%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop