LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/andyfighting[P]hiredis_timer_cmpt/read.c
// Function: seekNewline
static char *seekNewline(char *s, size_t len) {
    int pos = 0;
    int _len = len-1;

    /* Position should be < len-1 because the character at "pos" should be
     * followed by a \n. Note that strchr cannot be used because it doesn't
     * allow to search a limited length and the buffer that is being searched
     * might not have a trailing NULL character. */
    while (pos < _len) {
        while(pos < _len && s[pos] != '\r') pos++;
        if (s[pos] != '\r') {
            /* Not found. */
            return NULL;
        } else {
            if (s[pos+1] == '\n') {
                /* Found. */
                return s+pos;
            } else {
                /* Continue searching. */
                pos++;
            }
        }
    }
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
leal -0x1(%rsi), %ecx
movslq %ecx, %rdx
xorl %eax, %eax
movabsq $0x100000000, %r8       # imm = 0x100000000
xorl %r9d, %r9d
cmpl %ecx, %r9d
jge 0x802c
movslq %r9d, %r11
movq %r11, %r10
shlq $0x20, %r10
movq %rdx, %r14
subq %r11, %r14
addq %rdi, %r11
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x8003
cmpb $0xd, (%r11,%rbx)
je 0x800b
incq %rbx
addq %r8, %r10
jmp 0x7fef
movq %rdx, %r10
movl %esi, %r9d
jmp 0x8015
sarq $0x20, %r10
addl %ebx, %r9d
incl %r9d
cmpb $0xd, (%rdi,%r10)
jne 0x802c
movslq %r9d, %r11
cmpb $0xa, (%rdi,%r11)
jne 0x7fd5
addq %r10, %rdi
movq %rdi, %rax
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/scream10v3/sse/scream.c
// Function: tweak_expand
void tweak_expand(v16qi T[16], v16qi K[16], v16qi T3[48]) {
  int i;

  for (i = 0; i<16; i++)
    T3[i] = T[i];

  for (i = 0; i<8; i++) {
    T3[16+key_idx(i)]   = T[key_idx(i)] ^ T[key_idx(i+8)];
    T3[16+key_idx(i+8)] = T[key_idx(i)];
    T3[32+key_idx(i)]   = T[key_idx(i+8)];
    T3[32+key_idx(i+8)] = T[key_idx(i)] ^ T[key_idx(i+8)];
  }

  for (i = 0; i<48; i++)
    T3[i] ^= K[i%16];
}

// Assembly:
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x2254
vmovaps (%rdi,%rax), %xmm0
vmovaps %xmm0, (%rdx,%rax)
addq $0x10, %rax
jmp 0x223c
pushq %rbx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x8, %ecx
je 0x22f0
movl %ecx, %r8d
shrl %r8d
movl %eax, %r9d
andl $0x8, %r9d
leal (%r9,%r8), %r10d
addl $0x4, %r10d
movl %r9d, %r11d
orl %r8d, %r11d
shlq $0x4, %r11
shlq $0x4, %r10
vmovaps (%rdi,%r10), %xmm0
vxorps (%rdi,%r11), %xmm0, %xmm0
leal (%r9,%r8), %ebx
addl $0x10, %ebx
shlq $0x4, %rbx
vmovaps %xmm0, (%rdx,%rbx)
vmovaps (%rdi,%r11), %xmm0
leal (%r9,%r8), %ebx
addl $0x14, %ebx
shlq $0x4, %rbx
vmovaps %xmm0, (%rdx,%rbx)
vmovaps (%rdi,%r10), %xmm0
leal (%r9,%r8), %r10d
addl $0x20, %r10d
shlq $0x4, %r10
vmovaps %xmm0, (%rdx,%r10)
vxorps (%rdi,%r11), %xmm0, %xmm0
addl %r9d, %r8d
addl $0x24, %r8d
shlq $0x4, %r8
vmovaps %xmm0, (%rdx,%r8)
incl %ecx
addl $0x8, %eax
jmp 0x2259
xorl %eax, %eax
cmpq $0x30, %rax
je 0x2316
movl %eax, %ecx
andl $0xf, %ecx
shll $0x4, %ecx
vmovaps (%rdx), %xmm0
vxorps (%rsi,%rcx), %xmm0, %xmm0
vmovaps %xmm0, (%rdx)
incq %rax
addq $0x10, %rdx
jmp 0x22f2
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/scream10v3/sse/scream.c
// Function: tweakey_schedule
void tweakey_schedule(const uint8_t *restrict k,
		      const uint8_t *restrict n,
		      uint8_t ctrl,
		      v16qi *restrict TK) {
  v16qi *K = &TK[3*16];
  v16qi *T = &TK[4*16];
  v16qi C= {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  int j;

  for (j=0; j<16; j++) {
    K[key_idx(j)] = (v16qi) CV(k[j]);
  }
  for (j=0; j<11; j++) {
    T[key_idx(j)] = (v16qi) CV(n[j]);
  }

  T[key_idx(15)] = (v16qi) CV(ctrl);
  T[key_idx(14)] = C;
  T[key_idx(13)] = (v16qi) CV(0);
  T[key_idx(12)] = (v16qi) CV(0);
  T[key_idx(11)] = (v16qi) CV(0);

  tweak_expand(T, K, TK);
}

// Assembly:
movq %rsi, %rax
leaq 0x300(%rcx), %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x10, %r9
je 0x2357
vpbroadcastb (%rdi,%r9), %xmm0
movl %r9d, %r10d
shrl %r10d
movl %r8d, %r11d
andl $0x8, %r11d
orl %r10d, %r11d
shlq $0x4, %r11
vmovdqa %xmm0, (%rsi,%r11)
incq %r9
addl $0x8, %r8d
jmp 0x2328
leaq 0x400(%rcx), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0xb, %r9
je 0x2393
vpbroadcastb (%rax,%r9), %xmm0
movl %r9d, %r10d
shrl %r10d
movl %r8d, %r11d
andl $0x8, %r11d
orl %r10d, %r11d
shlq $0x4, %r11
vmovdqa %xmm0, (%rdi,%r11)
incq %r9
addl $0x8, %r8d
jmp 0x2364
vpbroadcastb %edx, %xmm0
vmovdqa %xmm0, 0x4f0(%rcx)
vmovaps 0x2167(%rip), %xmm0     # 0x4510
vmovaps %xmm0, 0x470(%rcx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x460(%rcx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x4d0(%rcx)
movq %rcx, %rdx
vzeroupper
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/scream10v3/sse/scream.c
// Function: tweakey_increment
void tweakey_increment(v16qi *TK, size_t idx) {
  v16qi *K = &TK[3*16];
  v16qi *T = &TK[4*16];

  T[key_idx(14)] += V(16);
  UPDATE(14);
  if (((idx+256) & 0xfff) == 0) {
    T[key_idx(13)] += V(1);
    UPDATE(13);
    if (((idx+256) & 0xfffff) == 0) {
      T[key_idx(12)] += V(1);
      UPDATE(12);
      if (((idx+256) & 0xfffffff) == 0) {
	T[key_idx(11)] += V(1);
	UPDATE(11);
      }
    }
  }
}

// Assembly:
vpbroadcastb 0x1c25(%rip), %xmm0 # 0x4002
vpaddb 0x470(%rdi), %xmm0, %xmm0
vmovdqa %xmm0, 0x470(%rdi)
vpxor 0x370(%rdi), %xmm0, %xmm1
vmovdqa %xmm1, 0x70(%rdi)
vmovdqa 0x330(%rdi), %xmm2
vmovdqa 0x430(%rdi), %xmm3
vpxor %xmm0, %xmm2, %xmm4
vpternlogq $0x96, %xmm0, %xmm3, %xmm2
vmovdqa %xmm2, 0x130(%rdi)
vmovdqa %xmm4, 0x230(%rdi)
vpxor %xmm3, %xmm1, %xmm0
vmovdqa %xmm0, 0x270(%rdi)
addq $0x100, %rsi            # imm = 0x100
testw $0xfff, %si             # imm = 0xFFF
je 0x2440
retq
vmovdqa 0x3a0(%rdi), %xmm1
vmovdqa 0x4a0(%rdi), %xmm2
vmovdqa 0x4e0(%rdi), %xmm3
vpcmpeqd %xmm0, %xmm0, %xmm0
vpsubb %xmm0, %xmm3, %xmm3
vmovdqa %xmm3, 0x4e0(%rdi)
vpxor 0x3e0(%rdi), %xmm3, %xmm4
vmovdqa %xmm4, 0xe0(%rdi)
vpxor %xmm3, %xmm1, %xmm5
vpternlogq $0x96, %xmm3, %xmm2, %xmm1
vmovdqa %xmm1, 0x1a0(%rdi)
vmovdqa %xmm5, 0x2a0(%rdi)
vpxor %xmm2, %xmm4, %xmm1
vmovdqa %xmm1, 0x2e0(%rdi)
testl $0xff000, %esi          # imm = 0xFF000
jne 0x243f
vmovdqa 0x320(%rdi), %xmm1
vmovdqa 0x420(%rdi), %xmm2
vmovdqa 0x460(%rdi), %xmm3
vpsubb %xmm0, %xmm3, %xmm0
vmovdqa %xmm0, 0x460(%rdi)
vpxor 0x360(%rdi), %xmm0, %xmm3
vmovdqa %xmm3, 0x60(%rdi)
vpxor %xmm0, %xmm1, %xmm4
vpternlogq $0x96, %xmm0, %xmm2, %xmm1
vmovdqa %xmm1, 0x120(%rdi)
vmovdqa %xmm4, 0x220(%rdi)
vpxor %xmm2, %xmm3, %xmm0
vmovdqa %xmm0, 0x260(%rdi)
testl $0xff00000, %esi        # imm = 0xFF00000
jne 0x243f
vmovdqa 0x390(%rdi), %xmm0
vmovdqa 0x490(%rdi), %xmm1
vmovdqa 0x4d0(%rdi), %xmm2
vpcmpeqd %xmm3, %xmm3, %xmm3
vpsubb %xmm3, %xmm2, %xmm2
vmovdqa %xmm2, 0x4d0(%rdi)
vpxor 0x3d0(%rdi), %xmm2, %xmm3
vmovdqa %xmm3, 0xd0(%rdi)
vmovdqa %xmm0, %xmm4
vpternlogq $0x96, %xmm2, %xmm1, %xmm4
vmovdqa %xmm4, 0x190(%rdi)
vpxor %xmm2, %xmm0, %xmm0
vmovdqa %xmm0, 0x290(%rdi)
vpxor %xmm1, %xmm3, %xmm0
vmovdqa %xmm0, 0x2d0(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_SetBytesInLaneToZero
void KeccakP1600_SetBytesInLaneToZero(void *state, unsigned int lanePosition, unsigned int offset, unsigned int length)
{
    UINT8 laneAsBytes[8];
    UINT32 low, high;
    UINT32 temp, temp0, temp1;
    UINT32 *stateAsHalfLanes = (UINT32*)state;

    memset(laneAsBytes, 0xFF, offset);
    memset(laneAsBytes+offset, 0x00, length);
    memset(laneAsBytes+offset+length, 0xFF, 8-offset-length);
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    low = *((UINT32*)(laneAsBytes+0));
    high = *((UINT32*)(laneAsBytes+4));
#else
    low = laneAsBytes[0]
        | ((UINT32)(laneAsBytes[1]) << 8)
        | ((UINT32)(laneAsBytes[2]) << 16)
        | ((UINT32)(laneAsBytes[3]) << 24);
    high = laneAsBytes[4]
        | ((UINT32)(laneAsBytes[5]) << 8)
        | ((UINT32)(laneAsBytes[6]) << 16)
        | ((UINT32)(laneAsBytes[7]) << 24);
#endif
    toBitInterleavingAndAND(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, 0x8(%rsp)
movl %edx, %r13d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl $0xff, %esi
movq %r13, %rdx
callq 0x5080
addq %rsp, %r13
addq $0x10, %r13
movl %ebp, %r14d
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x5080
addq %r14, %r13
addl %ebp, %r12d
pushq $0x8
popq %rdx
subl %r12d, %edx
movq %r13, %rdi
movl $0xff, %esi
callq 0x5080
movl (%r15), %eax
movl 0x4(%r15), %ecx
movl %eax, %esi
shrl %esi
xorl %eax, %esi
movl $0x22222222, %edx       # imm = 0x22222222
andl %edx, %esi
leal (%rsi,%rsi,2), %edi
xorl %eax, %edi
movl %edi, %eax
shrl $0x2, %eax
xorl %edi, %eax
movl $0xc0c0c0c, %esi        # imm = 0xC0C0C0C
andl %esi, %eax
leal (%rax,%rax,4), %eax
xorl %edi, %eax
movl %eax, %r8d
shrl $0x4, %r8d
xorl %eax, %r8d
movl $0xf000f0, %edi         # imm = 0xF000F0
andl %edi, %r8d
imull $0x11, %r8d, %r9d
xorl %eax, %r9d
movl %r9d, %eax
shrl $0x8, %eax
xorl %r9d, %eax
movl $0xff00, %r8d           # imm = 0xFF00
andl %r8d, %eax
imull $0x101, %eax, %eax      # imm = 0x101
xorl %r9d, %eax
movl %ecx, %r9d
shrl %r9d
xorl %ecx, %r9d
andl %edx, %r9d
leal (%r9,%r9,2), %edx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x2, %ecx
xorl %edx, %ecx
andl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl %edi, %edx
imull $0x11, %edx, %edx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x8, %ecx
xorl %edx, %ecx
andl %r8d, %ecx
imull $0x101, %ecx, %ecx      # imm = 0x101
xorl %edx, %ecx
movzwl %ax, %edx
movl %ecx, %esi
shll $0x10, %esi
orl %edx, %esi
addl %ebx, %ebx
movq 0x8(%rsp), %rdx
andl %esi, (%rdx,%rbx,4)
shrl $0x10, %eax
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %eax, %ecx
andl %ecx, 0x4(%rdx,%rbx,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_AddBytesInLane
void KeccakP1600_AddBytesInLane(void *state, unsigned int lanePosition, const unsigned char *data, unsigned int offset, unsigned int length)
{
    UINT8 laneAsBytes[8];
    UINT32 low, high;
    UINT32 temp, temp0, temp1;
    UINT32 *stateAsHalfLanes = (UINT32*)state;

    memset(laneAsBytes, 0, 8);
    memcpy(laneAsBytes+offset, data, length);
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    low = *((UINT32*)(laneAsBytes+0));
    high = *((UINT32*)(laneAsBytes+4));
#else
    low = laneAsBytes[0]
        | ((UINT32)(laneAsBytes[1]) << 8)
        | ((UINT32)(laneAsBytes[2]) << 16)
        | ((UINT32)(laneAsBytes[3]) << 24);
    high = laneAsBytes[4]
        | ((UINT32)(laneAsBytes[5]) << 8)
        | ((UINT32)(laneAsBytes[6]) << 16)
        | ((UINT32)(laneAsBytes[7]) << 24);
#endif
    toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
andq $0x0, (%rsp)
movl %ecx, %eax
leaq (%rsp,%rax), %rdi
movl %r8d, %eax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x56f0
movl (%rsp), %eax
movl 0x4(%rsp), %ecx
movl %eax, %esi
shrl %esi
xorl %eax, %esi
movl $0x22222222, %edx       # imm = 0x22222222
andl %edx, %esi
leal (%rsi,%rsi,2), %edi
xorl %eax, %edi
movl %edi, %eax
shrl $0x2, %eax
xorl %edi, %eax
movl $0xc0c0c0c, %esi        # imm = 0xC0C0C0C
andl %esi, %eax
leal (%rax,%rax,4), %eax
xorl %edi, %eax
movl %eax, %r8d
shrl $0x4, %r8d
xorl %eax, %r8d
movl $0xf000f0, %edi         # imm = 0xF000F0
andl %edi, %r8d
imull $0x11, %r8d, %r9d
xorl %eax, %r9d
movl %r9d, %eax
shrl $0x8, %eax
xorl %r9d, %eax
movl $0xff00, %r8d           # imm = 0xFF00
andl %r8d, %eax
imull $0x101, %eax, %eax      # imm = 0x101
xorl %r9d, %eax
movl %ecx, %r9d
shrl %r9d
xorl %ecx, %r9d
andl %edx, %r9d
leal (%r9,%r9,2), %edx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x2, %ecx
xorl %edx, %ecx
andl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
xorl %edx, %ecx
movl %ecx, %edx
shrl $0x4, %edx
xorl %ecx, %edx
andl %edi, %edx
imull $0x11, %edx, %edx
xorl %ecx, %edx
movl %edx, %ecx
shrl $0x8, %ecx
xorl %edx, %ecx
andl %r8d, %ecx
imull $0x101, %ecx, %ecx      # imm = 0x101
xorl %edx, %ecx
movzwl %ax, %edx
movl %ecx, %esi
shll $0x10, %esi
orl %edx, %esi
addl %ebx, %ebx
xorl %esi, (%r14,%rbx,4)
shrl $0x10, %eax
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl %eax, %ecx
xorl %ecx, 0x4(%r14,%rbx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_AddLanes
void KeccakP1600_AddLanes(void *state, const unsigned char *data, unsigned int laneCount)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    const UINT32 * pI = (const UINT32 *)data;
    UINT32 * pS = (UINT32*)state;
    UINT32 t, x0, x1;
    int i;
    for (i = laneCount-1; i >= 0; --i) {
#ifdef NO_MISALIGNED_ACCESSES
        UINT32 low;
        UINT32 high;
        memcpy(&low, pI++, 4);
        memcpy(&high, pI++, 4);
        toBitInterleavingAndXOR(low, high, *(pS++), *(pS++), t, x0, x1);
#else
        toBitInterleavingAndXOR(*(pI++), *(pI++), *(pS++), *(pS++), t, x0, x1)
#endif
    }
#else
    unsigned int lanePosition;
    for(lanePosition=0; lanePosition<laneCount; lanePosition++) {
        UINT8 laneAsBytes[8];
        memcpy(laneAsBytes, data+lanePosition*8, 8);
        UINT32 low = laneAsBytes[0]
            | ((UINT32)(laneAsBytes[1]) << 8)
            | ((UINT32)(laneAsBytes[2]) << 16)
            | ((UINT32)(laneAsBytes[3]) << 24);
        UINT32 high = laneAsBytes[4]
            | ((UINT32)(laneAsBytes[5]) << 8)
            | ((UINT32)(laneAsBytes[6]) << 16)
            | ((UINT32)(laneAsBytes[7]) << 24);
        UINT32 even, odd, temp, temp0, temp1;
        UINT32 *stateAsHalfLanes = (UINT32*)state;
        toBitInterleavingAndXOR(low, high, stateAsHalfLanes[lanePosition*2+0], stateAsHalfLanes[lanePosition*2+1], temp, temp0, temp1);
    }
#endif
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
decl %edx
xorl %eax, %eax
movl $0x22222222, %ecx       # imm = 0x22222222
movl $0xc0c0c0c, %r8d        # imm = 0xC0C0C0C
movl $0xf000f0, %r9d         # imm = 0xF000F0
movl $0xff00, %r10d          # imm = 0xFF00
testl %edx, %edx
js 0x5c5f
movl (%rsi,%rax), %r11d
movl 0x4(%rsi,%rax), %ebx
movl %r11d, %r14d
shrl %r14d
xorl %r11d, %r14d
andl %ecx, %r14d
leal (%r14,%r14,2), %ebp
xorl %r11d, %ebp
movl %ebp, %r11d
shrl $0x2, %r11d
xorl %ebp, %r11d
andl %r8d, %r11d
leal (%r11,%r11,4), %r11d
xorl %ebp, %r11d
movl %r11d, %ebp
shrl $0x4, %ebp
xorl %r11d, %ebp
andl %r9d, %ebp
imull $0x11, %ebp, %ebp
xorl %r11d, %ebp
movl %ebp, %r11d
shrl $0x8, %r11d
xorl %ebp, %r11d
andl %r10d, %r11d
imull $0x101, %r11d, %r11d    # imm = 0x101
xorl %ebp, %r11d
movl %ebx, %r14d
shrl %r14d
xorl %ebx, %r14d
andl %ecx, %r14d
leal (%r14,%r14,2), %ebp
xorl %ebx, %ebp
movl %ebp, %ebx
shrl $0x2, %ebx
xorl %ebp, %ebx
andl %r8d, %ebx
leal (%rbx,%rbx,4), %ebx
xorl %ebp, %ebx
movl %ebx, %ebp
shrl $0x4, %ebp
xorl %ebx, %ebp
andl %r9d, %ebp
imull $0x11, %ebp, %ebp
xorl %ebx, %ebp
movl %ebp, %ebx
shrl $0x8, %ebx
xorl %ebp, %ebx
andl %r10d, %ebx
imull $0x101, %ebx, %ebx      # imm = 0x101
xorl %ebp, %ebx
movzwl %r11w, %ebp
movl %ebx, %r14d
shll $0x10, %r14d
orl %ebp, %r14d
xorl %r14d, (%rdi,%rax)
shrl $0x10, %r11d
andl $0xffff0000, %ebx       # imm = 0xFFFF0000
orl %r11d, %ebx
xorl %ebx, 0x4(%rdi,%rax)
addq $0x8, %rax
decl %edx
jmp 0x5b8f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_OverwriteWithZeroes
void KeccakP1600_OverwriteWithZeroes(void *state, unsigned int byteCount)
{
    UINT32 *stateAsHalfLanes = (UINT32*)state;
    unsigned int i;

    for(i=0; i<byteCount/8; i++) {
        stateAsHalfLanes[i*2+0] = 0;
        stateAsHalfLanes[i*2+1] = 0;
    }
    if (byteCount%8 != 0)
        KeccakP1600_SetBytesInLaneToZero(state, byteCount/8, 0, byteCount%8);
}

// Assembly:
movl %esi, %ecx
shrl $0x3, %esi
xorl %eax, %eax
cmpq %rax, %rsi
je 0x5edf
andq $0x0, (%rdi,%rax,8)
incq %rax
jmp 0x5ed0
andl $0x7, %ecx
je 0x5eeb
xorl %edx, %edx
jmp 0x5100
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_ExtractLanes
void KeccakP1600_ExtractLanes(const void *state, unsigned char *data, unsigned int laneCount)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    UINT32 * pI = (UINT32 *)data;
    const UINT32 * pS = ( const UINT32 *)state;
    UINT32 t, x0, x1;
    int i;
    for (i = laneCount-1; i >= 0; --i) {
#ifdef NO_MISALIGNED_ACCESSES
        UINT32 low;
        UINT32 high;
        fromBitInterleaving(*(pS++), *(pS++), low, high, t, x0, x1);
        memcpy(pI++, &low, 4);
        memcpy(pI++, &high, 4);
#else
        fromBitInterleaving(*(pS++), *(pS++), *(pI++), *(pI++), t, x0, x1)
#endif
    }
#else
    unsigned int lanePosition;
    for(lanePosition=0; lanePosition<laneCount; lanePosition++) {
        UINT32 *stateAsHalfLanes = (UINT32*)state;
        UINT32 low, high, temp, temp0, temp1;
        fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1);
        UINT8 laneAsBytes[8];
        laneAsBytes[0] = low & 0xFF;
        laneAsBytes[1] = (low >> 8) & 0xFF;
        laneAsBytes[2] = (low >> 16) & 0xFF;
        laneAsBytes[3] = (low >> 24) & 0xFF;
        laneAsBytes[4] = high & 0xFF;
        laneAsBytes[5] = (high >> 8) & 0xFF;
        laneAsBytes[6] = (high >> 16) & 0xFF;
        laneAsBytes[7] = (high >> 24) & 0xFF;
        memcpy(data+lanePosition*8, laneAsBytes, 8);
    }
#endif
}

// Assembly:
decl %edx
xorl %eax, %eax
vpxor %xmm0, %xmm0, %xmm0
vpmovsxbd 0xb077(%rip), %xmm1 # 0x11048
vpmovsxbd 0xb072(%rip), %xmm2 # 0x1104c
vmovq 0xb03e(%rip), %xmm3     # 0x11020
vpbroadcastd 0xb045(%rip), %xmm4 # 0x11030
vpbroadcastd 0xb040(%rip), %xmm5 # 0x11034
vpbroadcastd 0xb03b(%rip), %xmm6 # 0x11038
vpbroadcastd 0xb036(%rip), %xmm7 # 0x1103c
vpbroadcastd 0xb031(%rip), %xmm8 # 0x11040
vpbroadcastd 0xb02c(%rip), %xmm9 # 0x11044
testl %edx, %edx
js 0x60c8
movq (%rdi,%rax), %rcx
vmovq %rcx, %xmm10
movq %rcx, %r8
shrq $0x20, %r8
shll $0x10, %r8d
vpblendw $0x9, %xmm10, %xmm0, %xmm11 # xmm11 = xmm10[0],xmm0[1,2],xmm10[3],xmm0[4,5,6,7]
vpsllq $0x20, %xmm10, %xmm12
vpinsrd $0x0, %r8d, %xmm12, %xmm12
vpsrlvd %xmm1, %xmm12, %xmm13
vpsrlvd %xmm2, %xmm12, %xmm12
shrq $0x28, %rcx
vpinsrd $0x1, %ecx, %xmm10, %xmm10
vpternlogd $0x28, %xmm3, %xmm13, %xmm10
vpslld $0x8, %xmm10, %xmm13
vpternlogd $0x1e, %xmm11, %xmm12, %xmm13
vpxor %xmm10, %xmm13, %xmm10
vpsrld $0x4, %xmm10, %xmm11
vpternlogd $0x28, %xmm4, %xmm13, %xmm11
vpmulld %xmm5, %xmm11, %xmm11
vpxor %xmm10, %xmm11, %xmm10
vpsrld $0x2, %xmm10, %xmm11
vpternlogd $0x28, %xmm6, %xmm10, %xmm11
vpmulld %xmm7, %xmm11, %xmm11
vpxor %xmm10, %xmm11, %xmm10
vpsrld $0x1, %xmm10, %xmm11
vpternlogd $0x28, %xmm8, %xmm10, %xmm11
vpmulld %xmm9, %xmm11, %xmm11
vpxor %xmm10, %xmm11, %xmm10
vmovq %xmm10, (%rsi,%rax)
addq $0x8, %rax
decl %edx
jmp 0x6018
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-1600-inplace32BI.c
// Function: KeccakP1600_ExtractAndAddBytesInLane
void KeccakP1600_ExtractAndAddBytesInLane(const void *state, unsigned int lanePosition, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    UINT32 *stateAsHalfLanes = (UINT32*)state;
    UINT32 low, high, temp, temp0, temp1;
    UINT8 laneAsBytes[8];
    unsigned int i;

    fromBitInterleaving(stateAsHalfLanes[lanePosition*2], stateAsHalfLanes[lanePosition*2+1], low, high, temp, temp0, temp1);
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    *((UINT32*)(laneAsBytes+0)) = low;
    *((UINT32*)(laneAsBytes+4)) = high;
#else
    laneAsBytes[0] = low & 0xFF;
    laneAsBytes[1] = (low >> 8) & 0xFF;
    laneAsBytes[2] = (low >> 16) & 0xFF;
    laneAsBytes[3] = (low >> 24) & 0xFF;
    laneAsBytes[4] = high & 0xFF;
    laneAsBytes[5] = (high >> 8) & 0xFF;
    laneAsBytes[6] = (high >> 16) & 0xFF;
    laneAsBytes[7] = (high >> 24) & 0xFF;
#endif
    for(i=0; i<length; i++)
        output[i] = input[i] ^ laneAsBytes[offset+i];
}

// Assembly:
addl %esi, %esi
movq (%rdi,%rsi,4), %rax
vmovq %rax, %xmm0
movq %rax, %rsi
shrq $0x20, %rsi
shll $0x10, %esi
vpxor %xmm1, %xmm1, %xmm1
vpsllq $0x20, %xmm0, %xmm2
vpinsrd $0x0, %esi, %xmm2, %xmm2
vpsrlvd 0xae6f(%rip), %xmm2, %xmm3 # 0x11000
vpsrlvd 0xae76(%rip), %xmm2, %xmm2 # 0x11010
vpblendw $0x9, %xmm0, %xmm1, %xmm1 # xmm1 = xmm0[0],xmm1[1,2],xmm0[3],xmm1[4,5,6,7]
shrq $0x28, %rax
vpinsrd $0x1, %eax, %xmm0, %xmm0
vpternlogd $0x28, 0xae6b(%rip), %xmm3, %xmm0 # 0x11020
vpslld $0x8, %xmm0, %xmm3
vpternlogd $0x1e, %xmm1, %xmm2, %xmm3
vpxor %xmm0, %xmm3, %xmm0
vpsrld $0x4, %xmm0, %xmm1
vpternlogd $0x28, 0xae5b(%rip){1to4}, %xmm3, %xmm1 # 0x11030
vpmulld 0xae55(%rip){1to4}, %xmm1, %xmm1 # 0x11034
vpxor %xmm0, %xmm1, %xmm0
vpsrld $0x2, %xmm0, %xmm1
vpternlogd $0x28, 0xae45(%rip){1to4}, %xmm0, %xmm1 # 0x11038
vpmulld 0xae3f(%rip){1to4}, %xmm1, %xmm1 # 0x1103c
vpxor %xmm0, %xmm1, %xmm0
vpsrld $0x1, %xmm0, %xmm1
vpternlogd $0x28, 0xae2f(%rip){1to4}, %xmm0, %xmm1 # 0x11040
vpmulld 0xae29(%rip){1to4}, %xmm1, %xmm1 # 0x11044
vpxor %xmm0, %xmm1, %xmm0
vmovq %xmm0, -0x8(%rsp)
movl %r9d, %eax
movl %r8d, %esi
xorl %edi, %edi
cmpq %rdi, %rax
je 0x6248
leal (%rsi,%rdi), %r8d
movb -0x8(%rsp,%r8), %r8b
xorb (%rdx,%rdi), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
jmp 0x622d
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_AddBytes
void KeccakP200_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

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

// Assembly:
pushq %rax
cmpl $0x19, %edx
jae 0x88ba
leal (%rcx,%rdx), %eax
cmpl $0x19, %eax
ja 0x88d9
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x88b8
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
jmp 0x88a2
popq %rax
retq
leaq 0x89f3(%rip), %rdi      # 0x112b4
leaq 0x89f8(%rip), %rsi      # 0x112c0
leaq 0x8a68(%rip), %rcx      # 0x11337
movl $0x94, %edx
callq 0x51c0
leaq 0x8aab(%rip), %rdi      # 0x1138b
leaq 0x89d9(%rip), %rsi      # 0x112c0
leaq 0x8a49(%rip), %rcx      # 0x11337
movl $0x95, %edx
callq 0x51c0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_ExtractAndAddBytes
void KeccakP200_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

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

// Assembly:
pushq %rax
cmpl $0x19, %ecx
jae 0x8ca9
leal (%r8,%rcx), %eax
cmpl $0x19, %eax
ja 0x8cc8
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x8ca7
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
jmp 0x8c8d
popq %rax
retq
leaq 0x8604(%rip), %rdi      # 0x112b4
leaq 0x8609(%rip), %rsi      # 0x112c0
leaq 0x87dd(%rip), %rcx      # 0x1149b
movl $0x168, %edx            # imm = 0x168
callq 0x51c0
leaq 0x86bc(%rip), %rdi      # 0x1138b
leaq 0x85ea(%rip), %rsi      # 0x112c0
leaq 0x87be(%rip), %rcx      # 0x1149b
movl $0x169, %edx            # imm = 0x169
callq 0x51c0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_DisplayRoundConstants
void KeccakP200_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8814(%rip), %r14      # 0x11510
leaq 0x883d(%rip), %r13      # 0x11540
leaq 0x8818(%rip), %r15      # 0x11522
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x12, %r12
je 0x8d47
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x56d0
movzbl (%r12,%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56d0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5380
incq %r12
jmp 0x8d10
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5380
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-200-reference.c
// Function: KeccakP200_DisplayRhoOffsets
void KeccakP200_DisplayRhoOffsets(FILE *f)
{
    unsigned int x, y;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x87eb(%rip), %r14      # 0x11560
leaq 0x87c0(%rip), %r15      # 0x1153c
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x5, %r12
je 0x8dd1
xorl %r13d, %r13d
cmpq $0x5, %r13
je 0x8dc8
movq %rbx, %rdi
leaq 0x878c(%rip), %rsi      # 0x11527
movl %r13d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x56d0
movl (%r14,%r13,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56d0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5380
incq %r13
jmp 0x8d8b
incq %r12
addq $0x14, %r14
jmp 0x8d82
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5380
nop
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-400-reference.c
// Function: KeccakP400_AddBytes
void KeccakP400_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

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

// Assembly:
pushq %rax
cmpl $0x32, %edx
jae 0x8e55
leal (%rcx,%rdx), %eax
cmpl $0x32, %eax
ja 0x8e74
movl %ecx, %eax
movl %edx, %ecx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x8e53
movb (%rsi,%rdx), %r8b
leal (%rcx,%rdx), %r9d
xorb %r8b, (%rdi,%r9)
incq %rdx
jmp 0x8e3d
popq %rax
retq
leaq 0x8768(%rip), %rdi      # 0x115c4
leaq 0x876d(%rip), %rsi      # 0x115d0
leaq 0x87dd(%rip), %rcx      # 0x11647
movl $0x96, %edx
callq 0x51c0
leaq 0x8820(%rip), %rdi      # 0x1169b
leaq 0x874e(%rip), %rsi      # 0x115d0
leaq 0x87be(%rip), %rcx      # 0x11647
movl $0x97, %edx
callq 0x51c0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-400-reference.c
// Function: KeccakP400_ExtractAndAddBytes
void KeccakP400_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

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

// Assembly:
pushq %rax
cmpl $0x32, %ecx
jae 0x9264
leal (%r8,%rcx), %eax
cmpl $0x32, %eax
ja 0x9283
movl %r8d, %eax
movl %ecx, %ecx
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x9262
leal (%rcx,%r8), %r9d
movb (%rdi,%r9), %r9b
xorb (%rsi,%r8), %r9b
movb %r9b, (%rdx,%r8)
incq %r8
jmp 0x9248
popq %rax
retq
leaq 0x8359(%rip), %rdi      # 0x115c4
leaq 0x835e(%rip), %rsi      # 0x115d0
leaq 0x8532(%rip), %rcx      # 0x117ab
movl $0x16a, %edx            # imm = 0x16A
callq 0x51c0
leaq 0x8411(%rip), %rdi      # 0x1169b
leaq 0x833f(%rip), %rsi      # 0x115d0
leaq 0x8513(%rip), %rcx      # 0x117ab
movl $0x16b, %edx            # imm = 0x16B
callq 0x51c0
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-400-reference.c
// Function: KeccakP400_DisplayRoundConstants
void KeccakP400_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8579(%rip), %r13      # 0x11830
leaq 0x8252(%rip), %r14      # 0x11510
leaq 0x855b(%rip), %r15      # 0x11820
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq $0x14, %r12
je 0x9306
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x56d0
movzwl (%r13), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x56d0
movl %ebp, %edi
movq %rbx, %rsi
callq 0x5380
incq %r12
addq $0x2, %r13
jmp 0x92cb
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5380
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-800-opt32.c
// Function: KeccakP800_AddBytes
void KeccakP800_AddBytes(void *argState, const unsigned char *data, unsigned int offset, unsigned int length)
{
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
    unsigned int sizeLeft = length;
    unsigned int lanePosition = offset/4;
    unsigned int offsetInLane = offset%4;
    const unsigned char *curData = data;
    UINT32 *state = (UINT32*)argState;

    state += lanePosition;
    if ((sizeLeft > 0) && (offsetInLane != 0)) {
        unsigned int bytesInLane = 4 - offsetInLane;
        UINT32 lane = 0;
        if (bytesInLane > sizeLeft)
            bytesInLane = sizeLeft;
        memcpy((unsigned char*)&lane + offsetInLane, curData, bytesInLane);
        *state++ ^= lane;
        sizeLeft -= bytesInLane;
        curData += bytesInLane;
    }

    while(sizeLeft >= 4) {
        *state++ ^= READ32_UNALIGNED( curData );
        sizeLeft -= 4;
        curData += 4;
    }

    if (sizeLeft > 0) {
        UINT32 lane = 0;
        memcpy(&lane, curData, sizeLeft);
        *state ^= lane;
    }
#else
#error "Not yet implemented"
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rsi, %rbx
movl %edx, %r15d
andl $-0x4, %r15d
addq %rdi, %r15
testl %ecx, %ecx
sete %al
andl $0x3, %edx
sete %cl
orb %al, %cl
jne 0x943c
andl $0x0, 0x8(%rsp)
pushq $0x4
popq %r14
subl %edx, %r14d
cmpl %ebp, %r14d
cmovael %ebp, %r14d
movl %edx, %eax
leaq (%rsp,%rax), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x56f0
movl 0x8(%rsp), %eax
xorl %eax, (%r15)
addq $0x4, %r15
subl %r14d, %ebp
addq %r14, %rbx
movl %ebp, %edx
xorl %r12d, %r12d
cmpl $0x4, %edx
jb 0x9458
movl (%rbx,%r12), %eax
xorl %eax, (%r15,%r12)
addq $-0x4, %rdx
addq $0x4, %r12
jmp 0x9441
testl %edx, %edx
je 0x947a
addq %r12, %rbx
leaq 0xc(%rsp), %r14
andl $0x0, (%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x56f0
movl (%r14), %eax
xorl %eax, (%r15,%r12)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/KeccakP-800-opt32.c
// Function: KeccakF800_FastLoop_Absorb
size_t KeccakF800_FastLoop_Absorb(void *state, unsigned int laneCount, const unsigned char *data, size_t dataByteLen)
{
    size_t originalDataByteLen = dataByteLen;
    unsigned int laneCountInBytes = laneCount*4;

    while(dataByteLen >= laneCountInBytes) {
#if (PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN)
        UINT32 * pState  = (UINT32*)state;
        unsigned int lc;

        for ( lc = laneCount; lc >= 4; lc -= 4 ) {
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
        }
        while ( lc-- != 0 ) {
            *pState++ ^= READ32_UNALIGNED( data );
            data += 4;
        }
#else
        KeccakP800_AddBytes(state, data, 0, laneCountInBytes);
        data += laneCountInBytes;
#endif
        KeccakP800_Permute_22rounds( state );
        dataByteLen -= laneCountInBytes;
    }
    return originalDataByteLen - dataByteLen;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leal (,%r15,4), %r13d
movl %esi, %ebp
movq %rcx, (%rsp)
movq %rcx, %rbx
subq %r13, %rbx
jb 0xa39d
xorl %eax, %eax
movq %r12, %rcx
movl %r15d, %edx
cmpl $0x3, %edx
jbe 0xa38c
movl (%r14), %esi
xorl %esi, (%rcx)
movl 0x4(%r14), %esi
xorl %esi, 0x4(%rcx)
movl 0x8(%r14), %esi
xorl %esi, 0x8(%rcx)
movl 0xc(%r14), %esi
xorl %esi, 0xc(%rcx)
addq $0x10, %rcx
addq $0x10, %r14
addl $-0x4, %edx
addq $0x4, %rax
jmp 0xa34e
movl (%r14), %ecx
xorl %ecx, (%r12,%rax,4)
addq $0x4, %r14
incq %rax
cmpl %eax, %ebp
jne 0xa37e
movq %r12, %rdi
callq 0x51a0
movq %rbx, %rcx
jmp 0xa341
movq (%rsp), %rax
subq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LakeKeyak_Instance instance;

    LakeKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 0, 0 );
    LakeKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %r9, %r15
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x20(%rsp)
movq %rdi, %rbp
movq 0x150(%rsp), %rsi
movq 0x148(%rsp), %rcx
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
andq $0x0, (%rsp)
leaq 0x28(%rsp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
movl $0x96, %r8d
xorl %r9d, %r9d
callq 0x53a0
leaq (%rbx,%rbp), %rax
movq %rax, (%rsp)
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq %r15, %r9
callq 0x5180
addq $0x10, %rbx
movq 0x20(%rsp), %rax
movq %rbx, (%rax)
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lakekeyakv2/generic32/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    LakeKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    LakeKeyak_Initialize( &instance, k, 16, npub, 150, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( LakeKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char *)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
cmpq $0x10, %r8
jae 0x10c04
pushq $-0x1
popq %rax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, %rbx
movq %r8, %r13
movq %rcx, %r14
movq %rsi, %rbp
movq %rdi, %r15
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rcx
andl $0x0, 0x10(%rsp)
andq $0x0, (%rsp)
pushq $0x1
popq %r12
movl %r12d, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
pushq $0x10
popq %rdx
movl $0x96, %r8d
xorl %r9d, %r9d
callq 0x53a0
leaq -0x10(%r13), %rcx
movq %rcx, (%rbp)
leaq (%r14,%r13), %rax
addq $-0x10, %rax
movl %r12d, 0x8(%rsp)
movq %rax, (%rsp)
andl $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %r8
movq 0x130(%rsp), %r9
callq 0x5180
movl %eax, %ecx
xorl %eax, %eax
cmpl %r12d, %ecx
setne %al
negl %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_gen_hash_function
unsigned int dict_gen_hash_function(const unsigned char *buf, int len)
{
    unsigned int hash = 5381;

    while (len--)
        hash = ((hash << 5) + hash) + (*buf++); /* hash * 33 + c */
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %ecx
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
cmpl %edx, %ecx
je 0x2523
imull $0x21, %eax, %esi
movzbl (%rdi,%rdx), %eax
addl %esi, %eax
incq %rdx
jmp 0x2511
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_gen_case_hash_function
unsigned int dict_gen_case_hash_function(const unsigned char *buf, int len)
{
    unsigned int hash = 5381;

    while (len--)
        hash = ((hash << 5) + hash) + (tolower(*buf++));        /* hash * 33 + c */
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r15d
movl $0x1505, %r14d          # imm = 0x1505
xorl %r12d, %r12d
cmpl %r12d, %r15d
je 0x255e
imull $0x21, %r14d, %r14d
callq 0x23c0
movq (%rax), %rax
movzbl (%rbx,%r12), %ecx
addl (%rax,%rcx,4), %r14d
incq %r12
jmp 0x253f
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_resize
int dict_resize(dict *d)
{
    int minimal;

    if (!dict_can_resize || dict_is_rehashing(d))
        return DICT_ERR;
    minimal = d->ht[0].used;
    if (minimal < DICT_HT_INITIAL_SIZE)
        minimal = DICT_HT_INITIAL_SIZE;
    return dict_expand(d, minimal);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x0, 0x8c50(%rip)      # 0xb1fc
jne 0x25b4
cmpl $-0x1, 0x48(%rdi)
je 0x25bb
movl $0x1, %eax
popq %rbp
retq
movl 0x20(%rdi), %eax
cmpl $0x5, %eax
movl $0x4, %esi
cmovgel %eax, %esi
popq %rbp
jmp 0x25cf
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_expand
int dict_expand(dict *d, unsigned long size)
{
    dictht n;                   /* the new hashtable */
    unsigned long realsize = _dict_next_power(size);

    /* the size is invalid if it is smaller than the number of
     * elements already inside the hashtable */
    if (dict_is_rehashing(d) || d->ht[0].used > size)
        return DICT_ERR;

    /* Allocate the new hashtable and initialize all pointers to NULL */
    n.size = realsize;
    n.sizemask = realsize - 1;
    n.table = (dict_entry**)calloc(1, realsize * sizeof(dict_entry *));
    n.used = 0;

    /* Is this the first initialization? If so it's not really a rehashing
     * we just set the first hash table so that it can accept keys. */
    if (d->ht[0].table == NULL)
    {
        d->ht[0] = n;
        return DICT_OK;
    }

    /* Prepare a second hash table for incremental rehashing */
    d->ht[1] = n;
    d->rehashidx = 0;
    return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x7ffffffffffffffe, %r14 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r14, %rsi
jbe 0x25f0
incq %r14
jmp 0x25fe
pushq $0x4
popq %rax
movq %rax, %r14
addq %rax, %rax
cmpq %rsi, %r14
jb 0x25f3
pushq $0x1
popq %rax
cmpl $-0x1, 0x48(%rbx)
jne 0x2652
cmpq %rsi, 0x20(%rbx)
ja 0x2652
leaq -0x1(%r14), %r15
leaq (,%r14,8), %rsi
pushq $0x1
popq %rdi
callq 0x21f0
cmpq $0x0, 0x8(%rbx)
je 0x263f
movq %rax, 0x28(%rbx)
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
andq $0x0, 0x40(%rbx)
andl $0x0, 0x48(%rbx)
jmp 0x2650
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %r15, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_rehash
int dict_rehash(dict *d, int n)
{
    if (!dict_is_rehashing(d))
        return 0;

    while (n--)
    {
        dict_entry *de, *nextde;

        /* Check if we already rehashed the whole table... */
        if (d->ht[0].used == 0)
        {
            free(d->ht[0].table);
            d->ht[0] = d->ht[1];
            _dict_reset(&d->ht[1]);
            d->rehashidx = -1;
            return 0;
        }

        /* Note that rehashidx can't overflow as we are sure there are more
         * elements because ht[0].used != 0 */
        while (d->ht[0].table[d->rehashidx] == NULL)
            d->rehashidx++;
        de = d->ht[0].table[d->rehashidx];
        /* Move all the keys in this bucket from the old to the new hash HT */
        while (de)
        {
            unsigned int h;

            nextde = de->next;
            /* Get the index in the new hash table */
            h = dict_gen_hash_function((const unsigned char*)de->key, de->keylen) & d->ht[1].sizemask;
            de->next = d->ht[1].table[h];
            d->ht[1].table[h] = de;
            d->ht[0].used--;
            d->ht[1].used++;
            de = nextde;
        }
        d->ht[0].table[d->rehashidx] = NULL;
        d->rehashidx++;
    }
    return 1;
}

// Assembly:
movl 0x48(%rdi), %eax
cmpl $-0x1, %eax
je 0x271b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl %eax, %ecx
leaq 0x8(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq 0x28(%rdi), %rax
movq %rax, -0x40(%rbp)
movl %ecx, %eax
subl $0x1, %esi
jb 0x271e
movq 0x8(%r14), %rdi
movq 0x20(%r14), %r12
testq %r12, %r12
je 0x2723
movl %esi, -0x30(%rbp)
movslq %eax, %rbx
leal 0x1(%rbx), %eax
movq (%rdi,%rbx,8), %r15
testq %r15, %r15
jne 0x26c4
incq %rbx
movl %eax, 0x48(%r14)
incl %eax
jmp 0x26b0
movl %eax, -0x2c(%rbp)
decq %r12
testq %r15, %r15
je 0x2703
movq 0x18(%r15), %r13
movq 0x8(%r15), %rdi
movl (%r15), %esi
callq 0x2504
andl 0x38(%r14), %eax
movq 0x28(%r14), %rcx
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x18(%r15)
movq %r15, (%rcx,%rax,8)
movq %r12, 0x20(%r14)
incq 0x40(%r14)
decq %r12
movq %r13, %r15
jmp 0x26ca
movq 0x8(%r14), %rax
andq $0x0, (%rax,%rbx,8)
movl -0x2c(%rbp), %eax
movl %eax, 0x48(%r14)
movl -0x30(%rbp), %esi
jmp 0x2691
xorl %eax, %eax
retq
pushq $0x1
popq %rax
jmp 0x274f
callq 0x2030
movq -0x40(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movq -0x38(%rbp), %rcx
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
orl $-0x1, 0x48(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_rehash_milliseconds
int dict_rehash_milliseconds(dict *d, int ms)
{
    long long start = time_in_milliseconds();
    int rehashes = 0;

    while (dict_rehash(d, 100))
    {
        rehashes += 100;
        if (time_in_milliseconds() - start > ms)
            break;
    }
    return rehashes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
callq 0x275e
movq %rax, %r15
movslq %r14d, %r13
xorl %r14d, %r14d
pushq $0x64
popq %r12
movq %rbx, %rdi
movl %r12d, %esi
callq 0x265d
testl %eax, %eax
je 0x27da
addl $0x64, %r14d
callq 0x275e
subq %r15, %rax
cmpq %r13, %rax
jle 0x27ba
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_add
int dict_add(dict *d, void *key, int keylen, void *val, int vallen)
{
    int index;
    dict_entry *entry;
    dictht *ht;

    if (dict_is_rehashing(d))
        _dict_rehash_step(d);

    /* Get the index of the new element, or -1 if
     * the element already exists. */
    if ((index = _dict_key_index(d, key, keylen)) == -1)
    {
        return DICT_ERR;
    }

    /* Allocates the memory and stores key */
    ht = dict_is_rehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = (dict_entry*)malloc(sizeof(*entry));

    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;

    /* Set the hash entry fields. */
    entry->key = key;
    entry->keylen = keylen;
    entry->val = val;
    entry->vallen = vallen;

    return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
cmpl $-0x1, 0x48(%rdi)
je 0x2821
movq %r13, %rdi
callq 0x295b
cmpl $-0x1, 0x48(%r13)
jne 0x2870
movq 0x10(%r13), %rcx
testq %rcx, %rcx
je 0x284f
movq 0x20(%r13), %rsi
cmpq %rcx, %rsi
jb 0x2870
cmpb $0x1, 0x89c2(%rip)      # 0xb1fc
jne 0x284a
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
cmpq $0x6, %rax
jb 0x2870
addq %rsi, %rsi
jmp 0x2852
pushq $0x4
popq %rsi
movq %r13, %rdi
callq 0x25cf
testl %eax, %eax
je 0x2870
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, -0x48(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r12, %rdi
movl %r15d, %esi
callq 0x2504
movl %eax, -0x30(%rbp)
movq %r13, -0x38(%rbp)
leaq 0x8(%r13), %rax
movq %rax, -0x50(%rbp)
movslq %r15d, %rbx
xorl %r13d, %r13d
movq %rax, -0x40(%rbp)
cmpq $0x2, %r13
je 0x28fa
movq %r13, %rax
shlq $0x5, %rax
movq -0x50(%rbp), %rdx
movl 0x10(%rdx,%rax), %ecx
andl -0x30(%rbp), %ecx
movq %rcx, -0x40(%rbp)
leaq (,%rcx,8), %r14
addq (%rdx,%rax), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x28ed
cmpl %r15d, (%r14)
jne 0x28e7
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x22c0
testl %eax, %eax
je 0x285e
addq $0x18, %r14
jmp 0x28c3
incq %r13
movq -0x38(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jne 0x289b
movq -0x40(%rbp), %rcx
cmpl $-0x1, %ecx
pushq $0x1
popq %rax
je 0x2861
xorl %ebx, %ebx
movq %rcx, %r13
movq -0x38(%rbp), %r14
cmpl $-0x1, 0x48(%r14)
setne %bl
shll $0x5, %ebx
pushq $0x20
popq %rdi
callq 0x22a0
movq 0x8(%r14,%rbx), %rcx
movslq %r13d, %rdx
movq (%rcx,%rdx,8), %rsi
movq %rsi, 0x18(%rax)
movq %rax, (%rcx,%rdx,8)
incq 0x20(%r14,%rbx)
movq %r12, 0x8(%rax)
movl %r15d, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x4(%rax)
xorl %eax, %eax
jmp 0x2861
// File: /workspace/github_c_makefile_star2_O2/buf1024[P]mysch/dict.c
// Function: dict_replace
int dict_replace(dict *d, void *key, int keylen, void *val, int vallen)
{
    dict_entry *entry, auxentry;

    /* Try to add the element. If the key
     * does not exists dictAdd will suceed. */
    if (dict_add(d, key, keylen, val, vallen) == DICT_OK)
        return 1;
    /* It already exists, get the entry */
    entry = dict_find(d, key, keylen);
    /* Free the old value and set the new one */
    /* Set the new value and free the old one. Note that it is important
     * to do that in this order, as the value may just be exactly the same
     * as the previous one. In this context, think to reference counting,
     * you want to increment (set), and then decrement (free), and not the
     * reverse. */
    auxentry = *entry;
    entry->val = val;
    entry->vallen = vallen;

    free(auxentry.val);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
callq 0x27ec
testl %eax, %eax
je 0x29ba
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x29cc
movq 0x10(%rax), %rdi
movq %r14, 0x10(%rax)
movl %ebx, 0x4(%rax)
callq 0x2030
xorl %eax, %eax
jmp 0x29bd
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq