LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/deflate.c
// Function: DeflateSplittingFirst
static void DeflateSplittingFirst(const ZopfliOptions* options,
                                  int btype, int final,
                                  const unsigned char* in,
                                  size_t instart, size_t inend,
                                  unsigned char* bp,
                                  unsigned char** out, size_t* outsize) {
  size_t i;
  size_t* splitpoints = 0;
  size_t npoints = 0;
  if (btype == 0) {
    ZopfliBlockSplitSimple(in, instart, inend, 65535, &splitpoints, &npoints);
  } else if (btype == 1) {
    /* If all blocks are fixed tree, splitting into separate blocks only
    increases the total size. Leave npoints at 0, this represents 1 block. */
  } else {
    ZopfliBlockSplit(options, in, instart, inend,
                     options->blocksplittingmax, &splitpoints, &npoints);
  }

  for (i = 0; i <= npoints; i++) {
    size_t start = i == 0 ? instart : splitpoints[i - 1];
    size_t end = i == npoints ? inend : splitpoints[i];
    DeflateBlock(options, btype, i == npoints && final, in, start, end,
                 bp, out, outsize);
  }

  free(splitpoints);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r13
xorl %eax, %eax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
cmpl $0x1, %esi
je 0x2a3d
testl %r12d, %r12d
jne 0x2a13
movq %rsp, %r8
leaq 0x8(%rsp), %r9
movl $0xffff, %ecx           # imm = 0xFFFF
movq %r15, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
callq 0x1c34
jmp 0x2a3d
movslq 0x10(%r13), %r8
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %r9
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq 0x18(%rsp), %rcx
pushq %rax
callq 0x1a8b
addq $0x10, %rsp
movq 0x8(%rsp), %rax
xorl %ebx, %ebx
movq %r14, %r8
testq %rbx, %rbx
je 0x2a55
movq (%rsp), %rcx
movq -0x8(%rcx,%rbx,8), %r8
movq 0x10(%rsp), %r9
cmpq %rax, %rbx
je 0x2a67
movq (%rsp), %rcx
movq (%rcx,%rbx,8), %r9
cmpq %rax, %rbx
sete %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
movzbl %cl, %edx
subq $0x8, %rsp
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rcx
pushq 0x68(%rsp)
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x2abe
addq $0x20, %rsp
incq %rbx
movq 0x8(%rsp), %rax
cmpq %rax, %rbx
jbe 0x2a44
movq (%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/deflate.c
// Function: ZopfliDeflate
void ZopfliDeflate(const ZopfliOptions* options, int btype, int final,
                   const unsigned char* in, size_t insize,
                   unsigned char* bp, unsigned char** out, size_t* outsize) {
#if ZOPFLI_MASTER_BLOCK_SIZE == 0
  ZopfliDeflatePart(options, btype, final, in, 0, insize, bp, out, outsize);
#else
  size_t i = 0;
  while (i < insize) {
    int masterfinal = (i + ZOPFLI_MASTER_BLOCK_SIZE >= insize);
    int final2 = final && masterfinal;
    size_t size = masterfinal ? insize - i : ZOPFLI_MASTER_BLOCK_SIZE;
    ZopfliDeflatePart(options, btype, final2,
                      in, i, i + size, bp, out, outsize);
    i += size;
  }
#endif
}

// Assembly:
testq %r8, %r8
je 0x2fb1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, %rbx
movq %rcx, %r12
movl %esi, %r15d
movq %rdi, %r13
xorl %r8d, %r8d
movl %edx, 0x4(%rsp)
testl %edx, %edx
setne %al
movl $0x1312d00, %r9d        # imm = 0x1312D00
leaq (%r8,%r9), %rdx
movq %rbx, %r14
subq %r8, %r14
cmpq %rbx, %rdx
cmovbq %r9, %r14
setae %dl
andb %al, %dl
movzbl %dl, %edx
addq %r8, %r14
subq $0x8, %rsp
movq %r13, %rdi
movl %r15d, %esi
movq %r12, %rcx
movq %r14, %r9
pushq 0x50(%rsp)
pushq 0x50(%rsp)
pushq %rbp
callq 0x2731
movl 0x24(%rsp), %edx
addq $0x20, %rsp
movq %r14, %r8
cmpq %rbx, %r14
jb 0x2f4e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/deflate.c
// Function: AddBits
static void AddBits(unsigned symbol, unsigned length,
                    unsigned char* bp, unsigned char** out, size_t* outsize) {
  /* TODO(lode): make more efficient (add more bits at once). */
  unsigned i;
  for (i = 0; i < length; i++) {
    unsigned bit = (symbol >> i) & 1;
    if (((*bp) & 7) == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
    (*out)[*outsize - 1] |= bit << ((*bp) & 7);
    (*bp)++;
  }
}

// Assembly:
testl %esi, %esi
je 0x38a8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %edx
xorl %r13d, %r13d
movl %esi, 0x4(%rsp)
movl %edi, (%rsp)
xorl %r12d, %r12d
btl %r13d, %edi
setb %bpl
testb $0x7, (%r15)
jne 0x3878
movq (%rbx), %rsi
leaq -0x1(%rsi), %rax
testq %rax, %rsi
jne 0x386b
testq %rsi, %rsi
je 0x3857
movq (%r14), %rdi
addq %rsi, %rsi
callq 0x1140
jmp 0x3861
movl $0x1, %edi
callq 0x1120
movq %rax, (%r14)
movl 0x4(%rsp), %edx
movl (%rsp), %edi
movq (%r14), %rax
movq (%rbx), %rcx
movb $0x0, (%rax,%rcx)
incq (%rbx)
movb %bpl, %r12b
movb (%r15), %cl
andb $0x7, %cl
shll %cl, %r12d
movq (%r14), %rax
movq (%rbx), %rcx
orb %r12b, -0x1(%rax,%rcx)
incb (%r15)
incl %r13d
cmpl %r13d, %edx
jne 0x3828
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/deflate.c
// Function: AddHuffmanBits
static void AddHuffmanBits(unsigned symbol, unsigned length,
                           unsigned char* bp, unsigned char** out,
                           size_t* outsize) {
  /* TODO(lode): make more efficient (add more bits at once). */
  unsigned i;
  for (i = 0; i < length; i++) {
    unsigned bit = (symbol >> (length - i - 1)) & 1;
    if (((*bp) & 7) == 0) ZOPFLI_APPEND_DATA(0, out, outsize);
    (*out)[*outsize - 1] |= bit << ((*bp) & 7);
    (*bp)++;
  }
}

// Assembly:
testl %esi, %esi
je 0x3946
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
decl %ebp
movl %edi, 0x4(%rsp)
xorl %r13d, %r13d
btl %ebp, %edi
setb %r12b
testb $0x7, (%r15)
jne 0x3919
movq (%rbx), %rsi
leaq -0x1(%rsi), %rax
testq %rax, %rsi
jne 0x390c
testq %rsi, %rsi
je 0x38fb
movq (%r14), %rdi
addq %rsi, %rsi
callq 0x1140
jmp 0x3905
movl $0x1, %edi
callq 0x1120
movq %rax, (%r14)
movl 0x4(%rsp), %edi
movq (%r14), %rax
movq (%rbx), %rcx
movb $0x0, (%rax,%rcx)
incq (%rbx)
movb %r12b, %r13b
movb (%r15), %cl
andb $0x7, %cl
shll %cl, %r13d
movq (%r14), %rax
movq (%rbx), %rcx
orb %r13b, -0x1(%rax,%rcx)
incb (%r15)
addl $-0x1, %ebp
jb 0x38cd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/hash.c
// Function: ZopfliCleanHash
void ZopfliCleanHash(ZopfliHash* h) {
  free(h->head);
  free(h->prev);
  free(h->hashval);

#ifdef ZOPFLI_HASH_SAME_HASH
  free(h->head2);
  free(h->prev2);
  free(h->hashval2);
#endif

#ifdef ZOPFLI_HASH_SAME
  free(h->same);
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x1030
movq 0x28(%rbx), %rdi
callq 0x1030
movq 0x30(%rbx), %rdi
callq 0x1030
movq 0x40(%rbx), %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/hash.c
// Function: ZopfliUpdateHash
void ZopfliUpdateHash(const unsigned char* array, size_t pos, size_t end,
                ZopfliHash* h) {
  unsigned short hpos = pos & ZOPFLI_WINDOW_MASK;
#ifdef ZOPFLI_HASH_SAME
  size_t amount = 0;
#endif

  UpdateHashValue(h, pos + ZOPFLI_MIN_MATCH <= end ?
      array[pos + ZOPFLI_MIN_MATCH - 1] : 0);
  h->hashval[hpos] = h->val;
  if (h->head[h->val] != -1 && h->hashval[h->head[h->val]] == h->val) {
    h->prev[hpos] = h->head[h->val];
  }
  else h->prev[hpos] = hpos;
  h->head[h->val] = hpos;

#ifdef ZOPFLI_HASH_SAME
  /* Update "same". */
  if (h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] > 1) {
    amount = h->same[(pos - 1) & ZOPFLI_WINDOW_MASK] - 1;
  }
  while (pos + amount + 1 < end &&
      array[pos] == array[pos + amount + 1] && amount < (unsigned short)(-1)) {
    amount++;
  }
  h->same[hpos] = amount;
#endif

#ifdef ZOPFLI_HASH_SAME_HASH
  h->val2 = ((h->same[hpos] - ZOPFLI_MIN_MATCH) & 255) ^ h->val;
  h->hashval2[hpos] = h->val2;
  if (h->head2[h->val2] != -1 && h->hashval2[h->head2[h->val2]] == h->val2) {
    h->prev2[hpos] = h->head2[h->val2];
  }
  else h->prev2[hpos] = hpos;
  h->head2[h->val2] = hpos;
#endif
}

// Assembly:
movl %esi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
leaq 0x3(%rsi), %r9
xorl %r8d, %r8d
cmpq %rdx, %r9
ja 0x4b0a
movzbl 0x2(%rdi,%rsi), %r8d
pushq %rbp
pushq %r14
pushq %rbx
movl 0x18(%rcx), %r10d
shll $0x5, %r10d
andl $0x7fe0, %r10d          # imm = 0x7FE0
xorl %r8d, %r10d
movl %r10d, 0x18(%rcx)
movq 0x10(%rcx), %r9
movl %esi, %r8d
andl $0x7fff, %r8d           # imm = 0x7FFF
movl %r8d, %r11d
movl %r10d, (%r9,%r11,4)
movq (%rcx), %r10
movslq 0x18(%rcx), %r11
movslq (%r10,%r11,4), %rbx
movl %eax, %ebp
cmpq $-0x1, %rbx
je 0x4b55
cmpl %r11d, (%r9,%rbx,4)
cmovnel %eax, %ebx
movl %ebx, %ebp
movq 0x8(%rcx), %r9
movw %bp, (%r9,%r8,2)
movzwl %ax, %r9d
movl %r9d, (%r10,%r11,4)
movq 0x40(%rcx), %r10
leal -0x1(%rsi), %r11d
andl $0x7fff, %r11d          # imm = 0x7FFF
movzwl (%r10,%r11,2), %ebx
leal -0x1(%rbx), %r14d
xorl %r11d, %r11d
cmpl $0x2, %ebx
cmovaeq %r14, %r11
leaq (%rsi,%r11), %rbx
incq %rbx
cmpq %rdx, %rbx
jae 0x4bcb
addq %rsi, %rdi
incq %rdi
movb -0x1(%rdi), %bpl
movq %rsi, %rbx
notq %rbx
addq %rdx, %rbx
incq %rsi
cmpq $0xfffe, %r11           # imm = 0xFFFE
ja 0x4bcb
cmpb (%rdi,%r11), %bpl
jne 0x4bcb
leaq (%rsi,%r11), %r14
incq %r14
incq %r11
cmpq %rdx, %r14
jb 0x4baa
movq %rbx, %r11
movw %r11w, (%r10,%r8,2)
addl $0xfd, %r11d
movzbl %r11b, %edx
xorl 0x18(%rcx), %edx
movl %edx, 0x38(%rcx)
movq 0x30(%rcx), %r10
movl %edx, (%r10,%r8,4)
movq 0x20(%rcx), %rdx
movslq 0x38(%rcx), %rsi
movslq (%rdx,%rsi,4), %rdi
cmpq $-0x1, %rdi
je 0x4c04
cmpl %esi, (%r10,%rdi,4)
cmovnel %eax, %edi
movl %edi, %eax
movq 0x28(%rcx), %rcx
movw %ax, (%rcx,%r8,2)
movl %r9d, (%rdx,%rsi,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/katajainen.c
// Function: BoundaryPM
static void BoundaryPM(Node* (*lists)[2], int maxbits,
    Node* leaves, int numsymbols, NodePool* pool, int index, char final) {
  Node* newchain;
  Node* oldchain;
  int lastcount = lists[index][1]->count;  /* Count of last chain of list. */

  if (index == 0 && lastcount >= numsymbols) return;

  newchain = GetFreeNode(lists, maxbits, pool);
  oldchain = lists[index][1];

  /* These are set up before the recursive calls below, so that there is a list
  pointing to the new node, to let the garbage collection know it's in use. */
  lists[index][0] = oldchain;
  lists[index][1] = newchain;

  if (index == 0) {
    /* New leaf node in list 0. */
    InitNode(leaves[lastcount].weight, lastcount + 1, 0, newchain);
  } else {
    size_t sum = lists[index - 1][0]->weight + lists[index - 1][1]->weight;
    if (lastcount < numsymbols && sum > leaves[lastcount].weight) {
      /* New leaf inserted in list, so count is incremented. */
      InitNode(leaves[lastcount].weight, lastcount + 1, oldchain->tail,
          newchain);
    } else {
      InitNode(sum, lastcount, lists[index - 1][1], newchain);
      if (!final) {
        /* Two lookahead chains of previous list used up, create new ones. */
        BoundaryPM(lists, maxbits, leaves, numsymbols, pool, index - 1, 0);
        BoundaryPM(lists, maxbits, leaves, numsymbols, pool, index - 1, 0);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movq %r8, 0x20(%rsp)
movl %ecx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdi, %r13
movb 0x60(%rsp), %bpl
movslq %r9d, %rax
decl %ebx
shlq $0x4, %rax
leaq (%rax,%rdi), %r14
addq $0x8, %r14
movq (%r14), %rax
movl 0x10(%rax), %r12d
cmpl $-0x1, %ebx
jne 0x5fcb
cmpl 0x10(%rsp), %r12d
jge 0x609a
movslq %r12d, %r15
movq %r13, %rdi
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x60a9
movq (%r14), %rcx
movq %rcx, -0x8(%r14)
movq %rax, (%r14)
cmpl $-0x1, %ebx
je 0x6063
movslq %ebx, %rdx
shlq $0x4, %rdx
movq (%r13,%rdx), %rdi
movq 0x8(%r13,%rdx), %rdx
movq (%rdx), %rsi
addq (%rdi), %rsi
cmpl 0x10(%rsp), %r12d
jge 0x601e
leaq (%r15,%r15,2), %rdi
movq 0x18(%rsp), %r8
movq (%r8,%rdi,8), %rdi
cmpq %rdi, %rsi
ja 0x6084
movq %rsi, (%rax)
movl %r12d, 0x10(%rax)
movq %rdx, 0x8(%rax)
movb $0x1, 0x14(%rax)
testb %bpl, %bpl
jne 0x609a
movl $0x0, (%rsp)
movq %r13, %rdi
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdx
movl 0x10(%rsp), %ecx
movq 0x20(%rsp), %r8
movl %ebx, %r9d
callq 0x5f78
decl %ebx
addq $-0x10, %r14
xorl %ebp, %ebp
jmp 0x5fb4
leaq (%r15,%r15,2), %rcx
movq 0x18(%rsp), %rdx
movq (%rdx,%rcx,8), %rcx
incl %r12d
movq %rcx, (%rax)
movl %r12d, 0x10(%rax)
movq $0x0, 0x8(%rax)
jmp 0x6096
incl %r12d
movq 0x8(%rcx), %rcx
movq %rdi, (%rax)
movl %r12d, 0x10(%rax)
movq %rcx, 0x8(%rax)
movb $0x1, 0x14(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/lz77.c
// Function: ZopfliCopyLZ77Store
void ZopfliCopyLZ77Store(
    const ZopfliLZ77Store* source, ZopfliLZ77Store* dest) {
  size_t i;
  ZopfliCleanLZ77Store(dest);
  dest->litlens =
      (unsigned short*)malloc(sizeof(*dest->litlens) * source->size);
  dest->dists = (unsigned short*)malloc(sizeof(*dest->dists) * source->size);

  if (!dest->litlens || !dest->dists) exit(-1); /* Allocation failed. */

  dest->size = source->size;
  for (i = 0; i < source->size; i++) {
    dest->litlens[i] = source->litlens[i];
    dest->dists[i] = source->dists[i];
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1030
movq 0x8(%r15), %rdi
callq 0x1030
movq 0x10(%rbx), %r13
leaq (,%r13,2), %r12
movq %r12, %rdi
callq 0x1120
movq %rax, %r14
movq %rax, (%r15)
movq %r12, %rdi
callq 0x1120
movq %rax, 0x8(%r15)
testq %r14, %r14
je 0x6735
testq %rax, %rax
je 0x6735
movq %r13, 0x10(%r15)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x672b
movq (%rbx), %rdx
movq 0x8(%rbx), %rsi
xorl %edi, %edi
movzwl (%rdx,%rdi,2), %r8d
movw %r8w, (%r14,%rdi,2)
movzwl (%rsi,%rdi,2), %r8d
movw %r8w, (%rax,%rdi,2)
incq %rdi
cmpq %rdi, %rcx
jne 0x670f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1170
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/lz77.c
// Function: ZopfliVerifyLenDist
void ZopfliVerifyLenDist(const unsigned char* data, size_t datasize, size_t pos,
                         unsigned short dist, unsigned short length) {

  /* TODO(lode): make this only run in a debug compile, it's for assert only. */
  size_t i;

  assert(pos + length <= datasize);
  for (i = 0; i < length; i++) {
    if (data[pos - dist + i] != data[pos + i]) {
      assert(data[pos - dist + i] == data[pos + i]);
      break;
    }
  }
}

// Assembly:
pushq %rax
movl %r8d, %eax
leaq (%rax,%rdx), %r9
cmpq %rsi, %r9
ja 0x682f
testw %r8w, %r8w
je 0x680e
leaq (%rdi,%rdx), %rsi
movzwl %cx, %ecx
subq %rcx, %rdx
addq %rdi, %rdx
xorl %ecx, %ecx
movb (%rdx,%rcx), %dil
cmpb (%rsi,%rcx), %dil
jne 0x6810
incq %rcx
cmpq %rcx, %rax
jne 0x67fc
popq %rax
retq
leaq 0x4279(%rip), %rdi      # 0xaa90
leaq 0x420b(%rip), %rsi      # 0xaa29
leaq 0x420b(%rip), %rcx      # 0xaa30
movl $0x5a, %edx
callq 0x10b0
leaq 0x41da(%rip), %rdi      # 0xaa10
leaq 0x41ec(%rip), %rsi      # 0xaa29
leaq 0x41ec(%rip), %rcx      # 0xaa30
movl $0x57, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/lz77.c
// Function: ZopfliLZ77Counts
void ZopfliLZ77Counts(const unsigned short* litlens,
                      const unsigned short* dists,
                      size_t start, size_t end,
                      size_t* ll_count, size_t* d_count) {
  size_t i;

  for (i = 0; i < 288; i++) {
    ll_count[i] = 0;
  }
  for (i = 0; i < 32; i++) {
    d_count[i] = 0;
  }

  for (i = start; i < end; i++) {
    if (dists[i] == 0) {
      ll_count[litlens[i]]++;
    } else {
      ll_count[ZopfliGetLengthSymbol(litlens[i])]++;
      d_count[ZopfliGetDistSymbol(dists[i])]++;
    }
  }

  ll_count[256] = 1;  /* End symbol. */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x900, %edx            # imm = 0x900
movq %r8, %rdi
xorl %esi, %esi
callq 0x10c0
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x10c0
cmpq %r15, %r12
jae 0x7453
cmpw $0x0, (%r13,%r12,2)
movzwl (%rbp,%r12,2), %edi
je 0x7444
callq 0x8a75
cltq
incq (%rbx,%rax,8)
movzwl (%r13,%r12,2), %edi
callq 0x8a34
cltq
leaq (%r14,%rax,8), %rax
jmp 0x7448
leaq (%rbx,%rdi,8), %rax
incq (%rax)
incq %r12
cmpq %r12, %r15
jne 0x7417
movq $0x1, 0x800(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: GetStatistics
static void GetStatistics(const ZopfliLZ77Store* store, SymbolStats* stats) {
  size_t i;
  for (i = 0; i < store->size; i++) {
    if (store->dists[i] == 0) {
      stats->litlens[store->litlens[i]]++;
    } else {
      stats->litlens[ZopfliGetLengthSymbol(store->litlens[i])]++;
      stats->dists[ZopfliGetDistSymbol(store->dists[i])]++;
    }
  }
  stats->litlens[256] = 1;  /* End symbol. */

  CalculateStatistics(stats);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x7abc
movq %rdi, %r14
leaq 0x900(%rbx), %r15
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpw $0x0, (%rcx,%r12,2)
movzwl (%rax,%r12,2), %edi
je 0x7aac
callq 0x8a75
cltq
incq (%rbx,%rax,8)
movq 0x8(%r14), %rax
movzwl (%rax,%r12,2), %edi
callq 0x8a34
cltq
leaq (%r15,%rax,8), %rax
jmp 0x7ab0
leaq (%rbx,%rdi,8), %rax
incq (%rax)
incq %r12
cmpq 0x10(%r14), %r12
jb 0x7a77
movq $0x1, 0x800(%rbx)
leaq 0xa00(%rbx), %rdx
movl $0x120, %esi            # imm = 0x120
movq %rbx, %rdi
callq 0x88ad
leaq 0x900(%rbx), %rdi
addq $0x1300, %rbx           # imm = 0x1300
movl $0x20, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ad
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: GetCostStat
static double GetCostStat(unsigned litlen, unsigned dist, void* context) {
  SymbolStats* stats = (SymbolStats*)context;
  if (dist == 0) {
    return stats->ll_symbols[litlen];
  } else {
    int lsym = ZopfliGetLengthSymbol(litlen);
    int lbits = ZopfliGetLengthExtraBits(litlen);
    int dsym = ZopfliGetDistSymbol(dist);
    int dbits = ZopfliGetDistExtraBits(dist);
    return stats->ll_symbols[lsym] + lbits + stats->d_symbols[dsym] + dbits;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %edi, %r14d
testl %esi, %esi
je 0x85cb
movl %esi, %ebp
movl %r14d, %edi
callq 0x8a75
movl %eax, %r15d
movl %r14d, %edi
callq 0x8a59
movl %eax, %r14d
movl %ebp, %edi
callq 0x8a34
movl %eax, %r12d
movl %ebp, %edi
callq 0x89f4
movslq %r15d, %rcx
cvtsi2sd %r14d, %xmm1
addsd 0xa00(%rbx,%rcx,8), %xmm1
movslq %r12d, %rcx
addsd 0x1300(%rbx,%rcx,8), %xmm1
cvtsi2sd %eax, %xmm0
addsd %xmm1, %xmm0
jmp 0x85d7
movl %r14d, %eax
movsd 0xa00(%rbx,%rax,8), %xmm0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: ZopfliLZ77OptimalFixed
void ZopfliLZ77OptimalFixed(ZopfliBlockState *s,
                            const unsigned char* in,
                            size_t instart, size_t inend,
                            ZopfliLZ77Store* store)
{
  /* Dist to get to here with smallest cost. */
  size_t blocksize = inend - instart;
  unsigned short* length_array =
      (unsigned short*)malloc(sizeof(unsigned short) * (blocksize + 1));
  unsigned short* path = 0;
  size_t pathsize = 0;

  if (!length_array) exit(-1); /* Allocation failed. */

  s->blockstart = instart;
  s->blockend = inend;

  /* Shortest path for fixed tree This one should give the shortest possible
  result for fixed tree, no repeated runs are needed since the tree is known. */
  LZ77OptimalRun(s, in, instart, inend, &path, &pathsize,
                 length_array, GetCostFixed, 0, store);

  free(length_array);
  free(path);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %rcx, %rax
subq %rdx, %rax
leaq 0x2(,%rax,2), %rdi
callq 0x1120
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0x8679
movq %r12, 0x10(%rbp)
movq %r15, 0x18(%rbp)
leaq 0x50(%rip), %rax        # 0x8683
leaq 0x10(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r8, %r15
pushq %rbx
pushq $0x0
pushq %rax
pushq %r14
callq 0x7b01
addq $0x20, %rsp
movq %r14, %rdi
callq 0x1030
movq (%r15), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1170
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/squeeze.c
// Function: GetCostFixed
static double GetCostFixed(unsigned litlen, unsigned dist, void* unused) {
  (void)unused;
  if (dist == 0) {
    if (litlen <= 143) return 8;
    else return 9;
  } else {
    int dbits = ZopfliGetDistExtraBits(dist);
    int lbits = ZopfliGetLengthExtraBits(litlen);
    int lsym = ZopfliGetLengthSymbol(litlen);
    double cost = 0;
    if (lsym <= 279) cost += 7;
    else cost += 8;
    cost += 5;  /* Every dist symbol has length 5. */
    return cost + dbits + lbits;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
testl %esi, %esi
je 0x86cc
movl %esi, %edi
callq 0x89f4
movl %eax, %ebp
movl %ebx, %edi
callq 0x8a59
movl %eax, %r14d
movl %ebx, %edi
callq 0x8a75
xorl %ecx, %ecx
cmpl $0x118, %eax            # imm = 0x118
cvtsi2sd %ebp, %xmm1
setl %cl
leaq 0x2794(%rip), %rax      # 0xae50
addsd (%rax,%rcx,8), %xmm1
cvtsi2sd %r14d, %xmm0
addsd %xmm1, %xmm0
jmp 0x86e3
xorl %eax, %eax
cmpl $0x90, %ebx
setb %al
leaq 0x2782(%rip), %rcx      # 0xae60
movsd (%rcx,%rax,8), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/tree.c
// Function: ZopfliLengthsToSymbols
void ZopfliLengthsToSymbols(const unsigned* lengths, size_t n, unsigned maxbits,
                            unsigned* symbols) {
  size_t* bl_count = (size_t*)malloc(sizeof(size_t) * (maxbits + 1));
  size_t* next_code = (size_t*)malloc(sizeof(size_t) * (maxbits + 1));
  unsigned bits, i;
  unsigned code;

  for (i = 0; i < n; i++) {
    symbols[i] = 0;
  }

  /* 1) Count the number of codes for each code length. Let bl_count[N] be the
  number of codes of length N, N >= 1. */
  for (bits = 0; bits <= maxbits; bits++) {
    bl_count[bits] = 0;
  }
  for (i = 0; i < n; i++) {
    assert(lengths[i] <= maxbits);
    bl_count[lengths[i]]++;
  }
  /* 2) Find the numerical value of the smallest code for each code length. */
  code = 0;
  bl_count[0] = 0;
  for (bits = 1; bits <= maxbits; bits++) {
    code = (code + bl_count[bits-1]) << 1;
    next_code[bits] = code;
  }
  /* 3) Assign numerical values to all codes, using consecutive values for all
  codes of the same length with the base values determined at step 2. */
  for (i = 0;  i < n; i++) {
    unsigned len = lengths[i];
    if (len != 0) {
      symbols[i] = next_code[len];
      next_code[len]++;
    }
  }

  free(bl_count);
  free(next_code);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leal 0x1(%rbp), %r13d
shlq $0x3, %r13
movq %r13, %rdi
callq 0x1120
movq %rax, %r12
movq %r13, %rdi
callq 0x1120
movq %rax, %r13
testq %r14, %r14
je 0x87dc
movl $0x1, %eax
xorl %ecx, %ecx
movl $0x0, (%rbx,%rcx,4)
movl %eax, %ecx
incl %eax
cmpq %r14, %rcx
jb 0x87cc
xorl %eax, %eax
movl %eax, %ecx
movq $0x0, (%r12,%rcx,8)
incl %eax
cmpl %ebp, %eax
jbe 0x87de
testq %r14, %r14
je 0x8813
movl $0x1, %eax
xorl %ecx, %ecx
movl (%r15,%rcx,4), %ecx
cmpl %ebp, %ecx
ja 0x888e
incq (%r12,%rcx,8)
movl %eax, %ecx
incl %eax
cmpq %r14, %rcx
jb 0x87fa
movq $0x0, (%r12)
testl %ebp, %ebp
je 0x8842
movl $0x1, %eax
xorl %ecx, %ecx
andl $-0x2, %ecx
leal -0x1(%rax), %edx
addq (%r12,%rdx,8), %rcx
addq %rcx, %rcx
movl %ecx, %edx
movl %eax, %esi
movq %rdx, (%r13,%rsi,8)
incl %eax
cmpl %ebp, %eax
jbe 0x8826
testq %r14, %r14
je 0x8870
movl $0x1, %eax
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
testq %rdx, %rdx
je 0x8867
movq (%r13,%rdx,8), %rsi
movl %esi, (%rbx,%rcx,4)
incq %rsi
movq %rsi, (%r13,%rdx,8)
movl %eax, %ecx
incl %eax
cmpq %r14, %rcx
jb 0x884e
movq %r12, %rdi
callq 0x1030
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
leaq 0x297b(%rip), %rdi      # 0xb210
leaq 0x298a(%rip), %rsi      # 0xb226
leaq 0x298a(%rip), %rcx      # 0xb22d
movl $0x2f, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/tree.c
// Function: ZopfliCalculateEntropy
void ZopfliCalculateEntropy(const size_t* count, size_t n, double* bitlengths) {
  static const double kInvLog2 = 1.4426950408889;  /* 1.0 / log(2.0) */
  unsigned sum = 0;
  unsigned i;
  double log2sum;
  for (i = 0; i < n; ++i) {
    sum += count[i];
  }
  log2sum = (sum == 0 ? log(n) : log(sum)) * kInvLog2;
  for (i = 0; i < n; ++i) {
    /* When the count of the symbol is 0, but its cost is requested anyway, it
    means the symbol will appear at least once anyway, so give it the cost as if
    its count is 1.*/
    if (count[i] == 0) bitlengths[i] = log2sum;
    else bitlengths[i] = log2sum - log(count[i]) * kInvLog2;
    /* Depending on compiler and architecture, the above subtraction of two
    floating point numbers may give a negative result very close to zero
    instead of zero (e.g. -5.973954e-17 with gcc 4.1.2 on Ubuntu 11.4). Clamp
    it to zero. These floating point imprecisions do not affect the cost model
    significantly so this is ok. */
    if (bitlengths[i] < 0 && bitlengths[i] > -1e-5) bitlengths[i] = 0;
    assert(bitlengths[i] >= 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x88df
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
addl (%r15,%rdx,8), %eax
movl %ecx, %edx
incl %ecx
cmpq %r14, %rdx
jb 0x88d0
jmp 0x88e1
xorl %eax, %eax
testl %eax, %eax
je 0x88ee
movl %eax, %eax
cvtsi2sd %rax, %xmm0
jmp 0x88f3
cvtsi2sd %r14, %xmm0
callq 0x10d0
testq %r14, %r14
je 0x899c
movapd %xmm0, %xmm1
mulsd 0x28eb(%rip), %xmm1     # 0xb1f8
movl $0x1, %ebp
xorl %r12d, %r12d
xorpd %xmm2, %xmm2
movsd %xmm1, 0x8(%rsp)
movq (%r15,%r12,8), %rax
movapd %xmm1, %xmm0
testq %rax, %rax
je 0x8968
movq %rax, %xmm1
punpckldq 0x19e7(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x19ef(%rip), %xmm1     # 0xa330
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x10d0
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x289c(%rip), %xmm0     # 0xb200
addsd %xmm1, %xmm0
movsd %xmm0, (%rbx,%r12,8)
ucomisd %xmm0, %xmm2
jbe 0x8986
ucomisd 0x288c(%rip), %xmm0     # 0xb208
jbe 0x8986
movq $0x0, (%rbx,%r12,8)
movsd (%rbx,%r12,8), %xmm0
ucomisd %xmm2, %xmm0
jb 0x89a9
movl %ebp, %r12d
incl %ebp
cmpq %r14, %r12
jb 0x891f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28d5(%rip), %rdi      # 0xb285
leaq 0x286f(%rip), %rsi      # 0xb226
leaq 0x28da(%rip), %rcx      # 0xb298
movl $0x5c, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/zopfli_bin.c
// Function: AddStrings
static char* AddStrings(const char* str1, const char* str2) {
  size_t len = strlen(str1) + strlen(str2);
  char* result = (char*)malloc(len + 1);
  if (!result) exit(-1); /* Allocation failed. */
  strcpy(result, str1);
  strcat(result, str2);
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1090
movq %rax, %r15
movq %rbx, %rdi
callq 0x1090
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1120
testq %rax, %rax
je 0x91e0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1160
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1170
nop
// File: /workspace/github_c_makefile_star2_O1/imaya[P]zopfli-for-emscripten/zopfli_lib.c
// Function: ZopfliCompress
void ZopfliCompress(const ZopfliOptions* options, ZopfliFormat output_type,
                    const unsigned char* in, size_t insize,
                    unsigned char** out, size_t* outsize)
{
  if (output_type == ZOPFLI_FORMAT_GZIP) {
    ZopfliGzipCompress(options, in, insize, out, outsize);
  } else if (output_type == ZOPFLI_FORMAT_ZLIB) {
    ZopfliZlibCompress(options, in, insize, out, outsize);
  } else if (output_type == ZOPFLI_FORMAT_DEFLATE) {
    unsigned char bp = 0;
    ZopfliDeflate(options, 2 /* Dynamic block */, 1,
                  in, insize, &bp, out, outsize);
  } else {
    assert(0);
  }
}

// Assembly:
pushq %rax
movq %r9, %rax
movq %r8, %r10
movq %rcx, %r8
movq %rdx, %rcx
cmpl $0x2, %esi
je 0x923d
cmpl $0x1, %esi
je 0x922b
testl %esi, %esi
jne 0x925e
movq %rcx, %rsi
movq %r8, %rdx
movq %r10, %rcx
movq %rax, %r8
popq %rax
jmp 0x3ef0
movq %rcx, %rsi
movq %r8, %rdx
movq %r10, %rcx
movq %rax, %r8
popq %rax
jmp 0x8a84
leaq 0x7(%rsp), %r9
movb $0x0, (%r9)
movl $0x2, %esi
movl $0x1, %edx
pushq %rax
pushq %r10
callq 0x2f24
addq $0x10, %rsp
popq %rax
retq
leaq 0x1e3b(%rip), %rdi      # 0xb0a0
leaq 0x30a4(%rip), %rsi      # 0xc310
leaq 0x30aa(%rip), %rcx      # 0xc31d
movl $0x23, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/page_fault1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long pgsize = getpagesize();

	while (1) {
		unsigned long i;

		char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
			       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
		assert(c != MAP_FAILED);

		for (i = 0; i < MEMSIZE; i += pgsize) {
			c[i] = 0;
			(*iterations)++;
		}

		munmap(c, MEMSIZE);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2270
movl %eax, %ebp
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x20e0
cmpq $-0x1, %rax
je 0x2c59
movslq %ebp, %r14
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq (%rbx)
addq %r14, %rcx
cmpq $0x8000000, %rcx        # imm = 0x8000000
jb 0x2c14
movl $0x8000000, %esi        # imm = 0x8000000
movq %rax, %rdi
callq 0x21d0
movl $0x8000000, %esi        # imm = 0x8000000
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x20e0
cmpq $-0x1, %rax
jne 0x2c12
leaq 0x624(%rip), %rdi       # 0x3284
leaq 0x62d(%rip), %rsi       # 0x3294
leaq 0x63a(%rip), %rcx       # 0x32a8
movl $0x13, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/src/dudect.h
// Function: randombytes
void randombytes(uint8_t *x, size_t how_much) {
  ssize_t i;
  static int fd = -1;

  ssize_t xlen = (ssize_t)how_much;
  assert(xlen >= 0);
  if (fd == -1) {
    for (;;) {
      fd = open("/dev/urandom", O_RDONLY);
      if (fd != -1)
        break;
      sleep(1);
    }
  }

  while (xlen > 0) {
    if (xlen < 1048576)
      i = xlen;
    else
      i = 1048576;

    i = read(fd, x, (size_t)i);
    if (i < 1) {
      sleep(1);
      continue;
    }

    x += i;
    xlen -= i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
js 0x12c1
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x1, 0x1ee76(%rip)    # 0x20090
jne 0x125f
leaq 0x1ced8(%rip), %rdi     # 0x1e0fb
xorl %esi, %esi
xorl %eax, %eax
callq 0x10d0
movl %eax, 0x1ee5e(%rip)     # 0x20090
cmpl $-0x1, %eax
jne 0x125f
leaq 0x1cebd(%rip), %r15     # 0x1e0fb
movl $0x1, %edi
callq 0x10f0
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10d0
movl %eax, 0x1ee36(%rip)     # 0x20090
cmpl $-0x1, %eax
je 0x123e
testq %rbx, %rbx
setne %bpl
je 0x12b8
movl $0x100000, %r12d        # imm = 0x100000
cmpq %r12, %rbx
movl $0x100000, %r15d        # imm = 0x100000
cmovlq %rbx, %r15
movl 0x1ee0f(%rip), %edi     # 0x20090
movq %r14, %rsi
movq %r15, %rdx
callq 0x10a0
testq %rax, %rax
jg 0x12a3
movl $0x1, %edi
callq 0x10f0
testb $0x1, %bpl
jne 0x127b
jmp 0x12b8
addq %rax, %r14
movq %rbx, %rcx
subq %rax, %rcx
testq %rcx, %rcx
setg %bpl
subq %rax, %rbx
jg 0x126e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1cdf8(%rip), %rdi     # 0x1e0c0
leaq 0x1cdfb(%rip), %rsi     # 0x1e0ca
leaq 0x1ce01(%rip), %rcx     # 0x1e0d7
movl $0xec, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: prepare_inputs
void prepare_inputs(dudect_config_t *c, uint8_t *input_data, uint8_t *classes) {
  randombytes(input_data, c->number_measurements * c->chunk_size);
  for (size_t i = 0; i < c->number_measurements; i++) {
    classes[i] = randombit();
    if (classes[i] == 0) {
      memset(input_data + (size_t)i * c->chunk_size, 0x00, c->chunk_size);
    } else {
      // leave random
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rsi
imulq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x11fc
cmpq $0x0, 0x8(%r15)
je 0x1877
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
movb $0x0, 0xf(%rsp)
movl $0x1, %esi
movq %r12, %rdi
callq 0x11fc
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, (%rbx,%r13)
jne 0x186e
movq (%r15), %rdx
movq %rdx, %rdi
imulq %r13, %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x1090
incq %r13
cmpq 0x8(%r15), %r13
jb 0x183c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/src/dudect.h
// Function: dudect_free
int dudect_free(dudect_ctx_t *ctx)
{
  for (int i = 0; i < DUDECT_TESTS; i++) {
    free(ctx->ttest_ctxs[i]);
  }
  free(ctx->percentiles);
  free(ctx->input_data);
  free(ctx->classes);
  free(ctx->exec_times);
  free(ctx->ticks);
  free(ctx->config);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x5, %r14d
movq (%rbx,%r14,8), %rdi
callq 0x1040
incq %r14
cmpq $0x6b, %r14
jne 0x1a51
movq 0x358(%rbx), %rdi
callq 0x1040
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
callq 0x1040
movq 0x8(%rbx), %rdi
callq 0x1040
movq (%rbx), %rdi
callq 0x1040
movq 0x20(%rbx), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/aesbitsliced/dut_aesbitsliced.c
// Function: do_one_computation
uint8_t do_one_computation(uint8_t *data) {
  uint8_t in[16] = {0};
  uint8_t out[16] = {0};
  uint8_t key[16] = {0x01,0};
  uint8_t ret = 0;

  memcpy(in, data, 16);
  crypto_stream(out, 16, in, key);
  ret ^= out[0];
  return ret;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbx
movaps %xmm0, (%rbx)
movaps 0x1c5e4(%rip), %xmm0    # 0x1e0a0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movups (%rdi), %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl $0x10, %esi
movq %rbx, %rdi
callq 0x148e0
movb (%rbx), %al
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/src/dudect.h
// Function: t_push
static void t_push(ttest_ctx_t *ctx, double x, uint8_t clazz) {
  assert(clazz == 0 || clazz == 1);
  ctx->n[clazz]++;
  /*
   estimate variance on the fly as per the Welford method.
   this gives good numerical stability, see Knuth's TAOCP vol 2
  */
  double delta = x - ctx->mean[clazz];
  ctx->mean[clazz] = ctx->mean[clazz] + delta / ctx->n[clazz];
  ctx->m2[clazz] = ctx->m2[clazz] + delta * (x - ctx->mean[clazz]);
}

// Assembly:
cmpb $0x2, %sil
jae 0x1b81
movzbl %sil, %eax
movsd (%rdi,%rax,8), %xmm1
movsd 0x20(%rdi,%rax,8), %xmm2
addsd 0x1c4f3(%rip), %xmm2    # 0x1e040
movsd %xmm2, 0x20(%rdi,%rax,8)
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
movapd %xmm3, %xmm4
divsd %xmm2, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, (%rdi,%rax,8)
subsd %xmm4, %xmm0
mulsd %xmm3, %xmm0
addsd 0x10(%rdi,%rax,8), %xmm0
movsd %xmm0, 0x10(%rdi,%rax,8)
retq
pushq %rax
leaq 0x1c652(%rip), %rdi     # 0x1e1db
leaq 0x1c53a(%rip), %rsi     # 0x1e0ca
leaq 0x1c65d(%rip), %rcx     # 0x1e1f4
movl $0xae, %edx
callq 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_shufb
void shufb(int128 *r, const unsigned char *l)
{
  int128   t;
  uint8_t *ct;
  uint8_t *cr;

  copy2(&t, r);
  cr = r->u8;
  ct = t.u8;
  cr[0] = ct[l[0]];
  cr[1] = ct[l[1]];
  cr[2] = ct[l[2]];
  cr[3] = ct[l[3]];
  cr[4] = ct[l[4]];
  cr[5] = ct[l[5]];
  cr[6] = ct[l[6]];
  cr[7] = ct[l[7]];
  cr[8] = ct[l[8]];
  cr[9] = ct[l[9]];
  cr[10] = ct[l[10]];
  cr[11] = ct[l[11]];
  cr[12] = ct[l[12]];
  cr[13] = ct[l[13]];
  cr[14] = ct[l[14]];
  cr[15] = ct[l[15]];
}

// Assembly:
movups (%rdi), %xmm0
movaps %xmm0, -0x18(%rsp)
movzbl (%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, (%rdi)
movzbl 0x1(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x1(%rdi)
movzbl 0x2(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x2(%rdi)
movzbl 0x3(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x3(%rdi)
movzbl 0x4(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x4(%rdi)
movzbl 0x5(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x5(%rdi)
movzbl 0x6(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x6(%rdi)
movzbl 0x7(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x7(%rdi)
movzbl 0x8(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x8(%rdi)
movzbl 0x9(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0x9(%rdi)
movzbl 0xa(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0xa(%rdi)
movzbl 0xb(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0xb(%rdi)
movzbl 0xc(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0xc(%rdi)
movzbl 0xd(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0xd(%rdi)
movzbl 0xe(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0xe(%rdi)
movzbl 0xf(%rsi), %eax
movb -0x18(%rsp,%rax), %al
movb %al, 0xf(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_shufd
void shufd(int128 *r, const int128 *x, const unsigned int c)
{
  int128 t;

  t.u32[0] = x->u32[c >> 0 & 3];
  t.u32[1] = x->u32[c >> 2 & 3];
  t.u32[2] = x->u32[c >> 4 & 3];
  t.u32[3] = x->u32[c >> 6 & 3];
  copy2(r, &t);
}

// Assembly:
movl %edx, %eax
andl $0x3, %eax
movl (%rsi,%rax,4), %eax
movl %edx, %ecx
shrl $0x2, %ecx
movl %edx, %r8d
andl $0xc, %r8d
movl (%rsi,%r8), %r8d
shlq $0x20, %r8
orq %rax, %r8
shrl $0x4, %edx
andl $0xc, %ecx
movl (%rsi,%rcx), %eax
andl $0xc, %edx
movl (%rsi,%rdx), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
movq %r8, (%rdi)
movq %rcx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_rshift32_littleendian
void rshift32_littleendian(int128 *r, const unsigned int n)
{
  unsigned char *rp = (unsigned char *)r;
  uint32 t;
  t = load32_littleendian(rp);
  t >>= n;
  store32_littleendian(rp, t);
  t = load32_littleendian(rp+4);
  t >>= n;
  store32_littleendian(rp+4, t);
  t = load32_littleendian(rp+8);
  t >>= n;
  store32_littleendian(rp+8, t);
  t = load32_littleendian(rp+12);
  t >>= n;
  store32_littleendian(rp+12, t);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1465a
movl %ebp, %ecx
shrl %cl, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x1465d
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq 0x1465a
movl %ebp, %ecx
shrl %cl, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x1465d
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x1465a
movl %ebp, %ecx
shrl %cl, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x1465d
addq $0xc, %rbx
movq %rbx, %rdi
callq 0x1465a
movl %ebp, %ecx
shrl %cl, %eax
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1465d
// File: /workspace/github_c_makefile_star2_O1/oreparaz[P]dudect/examples/aesbitsliced/int128_aes128ctr.c
// Function: crypto_stream_aes128ctr_portable_rshift64_littleendian
void rshift64_littleendian(int128 *r, const unsigned int n)
{
  unsigned char *rp = (unsigned char *)r;
  uint64 t;
  t = load64_littleendian(rp);
  t >>= n;
  store64_littleendian(rp, t);
  t = load64_littleendian(rp+8);
  t >>= n;
  store64_littleendian(rp+8, t);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x14660
movl %ebx, %ecx
shrq %cl, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x14664
addq $0x8, %r14
movq %r14, %rdi
callq 0x14660
movl %ebx, %ecx
shrq %cl, %rax
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14664
// File: /workspace/github_c_makefile_star2_O1/mjosaarinen[P]brutus/crypto_aead/aegis128l/ref/aes.c
// Function: AESROUND
void AESROUND(unsigned char *out, unsigned char *in, unsigned char *rk)
{
      ((U32*)out)[0] = ((U32*)TE0)[*(in+0)]  ^ ((U32*)TE1)[*(in+5)]  ^ ((U32*)TE2)[*(in+10)] ^ ((U32*)TE3)[*(in+15)] ^ ((U32*)rk)[0];
      ((U32*)out)[1] = ((U32*)TE0)[*(in+4)]  ^ ((U32*)TE1)[*(in+9)]  ^ ((U32*)TE2)[*(in+14)] ^ ((U32*)TE3)[*(in+3)]  ^ ((U32*)rk)[1];
      ((U32*)out)[2] = ((U32*)TE0)[*(in+8)]  ^ ((U32*)TE1)[*(in+13)] ^ ((U32*)TE2)[*(in+2)]  ^ ((U32*)TE3)[*(in+7)]  ^ ((U32*)rk)[2];
      ((U32*)out)[3] = ((U32*)TE0)[*(in+12)] ^ ((U32*)TE1)[*(in+1)]  ^ ((U32*)TE2)[*(in+6)]  ^ ((U32*)TE3)[*(in+11)] ^ ((U32*)rk)[3];
}

// Assembly:
movzbl (%rsi), %r8d
movq 0x2e29(%rip), %rax      # 0x3fe0
movzbl 0x5(%rsi), %r9d
movq 0x2e2d(%rip), %rcx      # 0x3ff0
movl (%rcx,%r9,4), %r10d
xorl (%rax,%r8,4), %r10d
movzbl 0xa(%rsi), %r9d
movq 0x2e21(%rip), %r8       # 0x3ff8
xorl (%r8,%r9,4), %r10d
movzbl 0xf(%rsi), %r11d
movq 0x2dd9(%rip), %r9       # 0x3fc0
xorl (%r9,%r11,4), %r10d
xorl (%rdx), %r10d
movl %r10d, (%rdi)
movzbl 0x4(%rsi), %r10d
movzbl 0x9(%rsi), %r11d
movl (%rcx,%r11,4), %r11d
xorl (%rax,%r10,4), %r11d
movzbl 0xe(%rsi), %r10d
xorl (%r8,%r10,4), %r11d
movzbl 0x3(%rsi), %r10d
xorl (%r9,%r10,4), %r11d
xorl 0x4(%rdx), %r11d
movl %r11d, 0x4(%rdi)
movzbl 0x8(%rsi), %r10d
movzbl 0xd(%rsi), %r11d
movl (%rcx,%r11,4), %r11d
xorl (%rax,%r10,4), %r11d
movzbl 0x2(%rsi), %r10d
xorl (%r8,%r10,4), %r11d
movzbl 0x7(%rsi), %r10d
xorl (%r9,%r10,4), %r11d
xorl 0x8(%rdx), %r11d
movl %r11d, 0x8(%rdi)
movzbl 0xc(%rsi), %r10d
movzbl 0x1(%rsi), %r11d
movl (%rcx,%r11,4), %ecx
xorl (%rax,%r10,4), %ecx
movzbl 0x6(%rsi), %eax
xorl (%r8,%rax,4), %ecx
movzbl 0xb(%rsi), %eax
xorl (%r9,%rax,4), %ecx
xorl 0xc(%rdx), %ecx
movl %ecx, 0xc(%rdi)
retq
nop
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/4-ProcessKernel/zombie.c
// Function: main
int main(void) {
	int pid;
	if( (pid = fork()) != 0 ) {
		printf("Look at the status of the child process %d\n", pid);
		while( getchar() != '\n' );		// block stdin until a newline.
		wait(NULL);
		printf("Look again!\n");
		while( getchar() != '\n' );
	}
	return 0;
}

// Assembly:
pushq %rax
callq 0x1070
testl %eax, %eax
je 0x11bd
leaq 0xe77(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x1040
callq 0x1050
cmpl $0xa, %eax
jne 0x1196
xorl %edi, %edi
callq 0x1060
leaq 0xe82(%rip), %rdi       # 0x2030
callq 0x1030
callq 0x1050
cmpl $0xa, %eax
jne 0x11b3
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_strtok_r.c
// Function: thread_func
void *thread_func(void *input)
{
	char *token;
	char *saveptr;		// the thread-specific data for reentrant
	int i = 0, thread_num;

	thread_num = ((char *) input)[strlen(input) - 1] - '0';
	printf("Thread %d: I start with the input %s\n", thread_num, (char *) input);

	token = strtok_r((char *) input, " ", &saveptr);		// initial step for strtok_r()
	do
	{
		printf("Thread %d: Token %d = %s\n", thread_num, i++, token);
		sleep(1);
	} while((token = strtok_r(NULL, " ", &saveptr)) != NULL);	// later steps for strtok_r()

	printf("Thread %d: terminated.\n", thread_num);

	pthread_exit(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
callq 0x1030
movsbl -0x1(%r12,%rax), %ebx
addl $-0x30, %ebx
leaq 0xe34(%rip), %rdi       # 0x2004
movl %ebx, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1040
leaq 0xe47(%rip), %r14       # 0x202a
leaq 0x8(%rsp), %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
leaq 0xe2f(%rip), %r12       # 0x202c
xorl %edx, %edx
leal 0x1(%rdx), %ebp
movq %r12, %rdi
movl %ebx, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x1040
movl $0x1, %edi
callq 0x10a0
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1050
movl %ebp, %edx
testq %rax, %rax
jne 0x11ff
leaq 0xe10(%rip), %rdi       # 0x2046
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
xorl %edi, %edi
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/eric-lo[P]3150/8-Synchronization/pthread_strtok_r.c
// Function: main
int main(void)
{
	pthread_t tid[THREAD];
	char buf[THREAD][STR_MAX];
	int i;

	for(i = 0; i < THREAD; i++)
	{
		sprintf(buf[i], "Thread %d says: Linux is a cool operating system %d", i, i);
		pthread_create(&tid[i], NULL, thread_func, buf[i]);
	}

	for(i = 0; i < THREAD; i++)
		pthread_join(tid[i], NULL);

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x810, %rsp            # imm = 0x810
movq %rsp, %rbx
leaq 0x10(%rsp), %r14
leaq 0xdf9(%rip), %r15       # 0x205e
leaq -0xc0(%rip), %r12       # 0x11ac
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0x1080
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1070
incq %r13
addq $0x8, %rbx
addq $0x400, %r14            # imm = 0x400
cmpq $0x1, %r13
je 0x126f
xorl %ebx, %ebx
movq (%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1090
incq %rbx
cmpq $0x1, %rbx
je 0x12a8
xorl %eax, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq