LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x75a2
cmpw $0x0, (%r13,%r12,2)
movzwl (%rbp,%r12,2), %edi
je 0x7593
callq 0x8bd5
cltq
incq (%rbx,%rax,8)
movzwl (%r13,%r12,2), %edi
callq 0x8b94
cltq
leaq (%r14,%rax,8), %rax
jmp 0x7597
leaq (%rbx,%rdi,8), %rax
incq (%rax)
incq %r12
cmpq %r12, %r15
jne 0x7566
movq $0x1, 0x800(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7c03
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 0x7bf3
callq 0x8bd5
cltq
incq (%rbx,%rax,8)
movq 0x8(%r14), %rax
movzwl (%rax,%r12,2), %edi
callq 0x8b94
cltq
leaq (%r15,%rax,8), %rax
jmp 0x7bf7
leaq (%rbx,%rdi,8), %rax
incq (%rax)
incq %r12
cmpq 0x10(%r14), %r12
jb 0x7bbe
movq $0x1, 0x800(%rbx)
leaq 0xa00(%rbx), %rdx
movl $0x120, %esi            # imm = 0x120
movq %rbx, %rdi
callq 0x8a09
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 0x8a09
// File: /workspace/github_c_makefile_star2_O3/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 0x8726
movl %esi, %ebp
movl %r14d, %edi
callq 0x8bd5
movl %eax, %r15d
movl %r14d, %edi
callq 0x8bb9
movl %eax, %r14d
movl %ebp, %edi
callq 0x8b94
movl %eax, %r12d
movl %ebp, %edi
callq 0x8b54
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 0x8732
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_O3/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 0x1130
movq %rax, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
testq %r14, %r14
je 0x87d4
movq %r12, 0x10(%rbp)
movq %r15, 0x18(%rbp)
leaq 0x50(%rip), %rax        # 0x87de
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 0x7c48
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 0x1180
// File: /workspace/github_c_makefile_star2_O3/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 0x8827
movl %esi, %edi
callq 0x8b54
movl %eax, %ebp
movl %ebx, %edi
callq 0x8bb9
movl %eax, %r14d
movl %ebx, %edi
callq 0x8bd5
xorl %ecx, %ecx
cmpl $0x118, %eax            # imm = 0x118
cvtsi2sd %ebp, %xmm1
setl %cl
leaq 0x2629(%rip), %rax      # 0xae40
addsd (%rax,%rcx,8), %xmm1
cvtsi2sd %r14d, %xmm0
addsd %xmm1, %xmm0
jmp 0x883e
xorl %eax, %eax
cmpl $0x90, %ebx
setb %al
leaq 0x2617(%rip), %rcx      # 0xae50
movsd (%rcx,%rax,8), %xmm0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1130
movq %rax, %r12
movq %r13, %rdi
callq 0x1130
movq %rax, %r13
testq %r14, %r14
je 0x8938
movl $0x1, %eax
xorl %ecx, %ecx
movl $0x0, (%rbx,%rcx,4)
movl %eax, %ecx
incl %eax
cmpq %r14, %rcx
jb 0x8928
xorl %eax, %eax
movl %eax, %ecx
movq $0x0, (%r12,%rcx,8)
incl %eax
cmpl %ebp, %eax
jbe 0x893a
testq %r14, %r14
je 0x896f
movl $0x1, %eax
xorl %ecx, %ecx
movl (%r15,%rcx,4), %ecx
cmpl %ebp, %ecx
ja 0x89ea
incq (%r12,%rcx,8)
movl %eax, %ecx
incl %eax
cmpq %r14, %rcx
jb 0x8956
movq $0x0, (%r12)
testl %ebp, %ebp
je 0x899e
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 0x8982
testq %r14, %r14
je 0x89cc
movl $0x1, %eax
xorl %ecx, %ecx
movl (%r15,%rcx,4), %edx
testq %rdx, %rdx
je 0x89c3
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 0x89aa
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 0x280f(%rip), %rdi      # 0xb200
leaq 0x281e(%rip), %rsi      # 0xb216
leaq 0x281e(%rip), %rcx      # 0xb21d
movl $0x2f, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rbx
testq %rsi, %rsi
je 0x8a46
movq %rdx, %r14
movq %rdi, %r15
xorl %edx, %edx
movl $0x1, %ecx
xorl %eax, %eax
addl (%r15,%rdx,8), %eax
movl %ecx, %edx
incl %ecx
cmpq %rbx, %rdx
jb 0x8a2c
testl %eax, %eax
je 0x8a5c
movl %eax, %eax
cvtsi2sd %rax, %xmm0
jmp 0x8a61
cvtsi2sd %rbx, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
cvtsi2sd %rbx, %xmm0
callq 0x10d0
movapd %xmm0, %xmm1
mulsd 0x2776(%rip), %xmm1     # 0xb1e8
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 0x8acd
movq %rax, %xmm1
punpckldq 0x1882(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x188a(%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 0x2727(%rip), %xmm0     # 0xb1f0
addsd %xmm1, %xmm0
movsd %xmm0, (%r14,%r12,8)
ucomisd %xmm0, %xmm2
jbe 0x8aed
ucomisd 0x2717(%rip), %xmm0     # 0xb1f8
jbe 0x8aed
movq $0x0, (%r14,%r12,8)
jmp 0x8af3
ucomisd %xmm2, %xmm0
jb 0x8b0a
movl %ebp, %r12d
incl %ebp
cmpq %rbx, %r12
jb 0x8a84
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2764(%rip), %rdi      # 0xb275
leaq 0x26fe(%rip), %rsi      # 0xb216
leaq 0x2769(%rip), %rcx      # 0xb288
movl $0x5c, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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 0x1130
testq %rax, %rax
je 0x9368
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1170
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1180
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x93c5
cmpl $0x1, %esi
je 0x93b3
testl %esi, %esi
jne 0x93e6
movq %rcx, %rsi
movq %r8, %rdx
movq %r10, %rcx
movq %rax, %r8
popq %rax
jmp 0x4004
movq %rcx, %rsi
movq %r8, %rdx
movq %r10, %rcx
movq %rax, %r8
popq %rax
jmp 0x8be4
leaq 0x7(%rsp), %r9
movb $0x0, (%r9)
movl $0x2, %esi
movl $0x1, %edx
pushq %rax
pushq %r10
callq 0x2f25
addq $0x10, %rsp
popq %rax
retq
leaq 0x1ca3(%rip), %rdi      # 0xb090
leaq 0x2f0c(%rip), %rsi      # 0xc300
leaq 0x2f12(%rip), %rcx      # 0xc30d
movl $0x23, %edx
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/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 0x2cf1
movslq %ebp, %r14
xorl %ecx, %ecx
movb $0x0, (%rax,%rcx)
incq (%rbx)
addq %r14, %rcx
cmpq $0x8000000, %rcx        # imm = 0x8000000
jb 0x2cac
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 0x2caa
leaq 0x5cc(%rip), %rdi       # 0x32c4
leaq 0x5d5(%rip), %rsi       # 0x32d4
leaq 0x5e2(%rip), %rcx       # 0x32e8
movl $0x13, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x12ad
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
je 0x12a1
movl $0x100000, %r12d        # imm = 0x100000
cmpq %r12, %rbx
movl $0x100000, %r15d        # imm = 0x100000
cmovbq %rbx, %r15
movl 0x1ee13(%rip), %edi     # 0x20090
movq %r14, %rsi
movq %r15, %rdx
callq 0x10a0
testq %rax, %rax
jg 0x1299
movl $0x1, %edi
callq 0x10f0
jmp 0x1277
addq %rax, %r14
subq %rax, %rbx
jg 0x126a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1ce0c(%rip), %rdi     # 0x1e0c0
leaq 0x1ce0f(%rip), %rsi     # 0x1e0ca
leaq 0x1ce15(%rip), %rcx     # 0x1e0d7
movl $0xec, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/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 0x185f
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 0x1856
movq (%r15), %rdx
movq %rdx, %rdi
imulq %r13, %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x1090
incq %r13
cmpq 0x8(%r15), %r13
jb 0x1824
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c60a(%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 0x1483c
movb (%rbx), %al
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b5b
movzbl %sil, %eax
movsd (%rdi,%rax,8), %xmm1
movsd 0x20(%rdi,%rax,8), %xmm2
addsd 0x1c519(%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 0x1c678(%rip), %rdi     # 0x1e1db
leaq 0x1c560(%rip), %rsi     # 0x1e0ca
leaq 0x1c683(%rip), %rcx     # 0x1e1f4
movl $0xae, %edx
callq 0x1080
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x145b6
movl %ebp, %ecx
shrl %cl, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x145b9
leaq 0x4(%rbx), %r14
movq %r14, %rdi
callq 0x145b6
movl %ebp, %ecx
shrl %cl, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x145b9
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x145b6
movl %ebp, %ecx
shrl %cl, %eax
movq %r14, %rdi
movl %eax, %esi
callq 0x145b9
addq $0xc, %rbx
movq %rbx, %rdi
callq 0x145b6
movl %ebp, %ecx
shrl %cl, %eax
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x145b9
// File: /workspace/github_c_makefile_star2_O3/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 0x145bc
movl %ebx, %ecx
shrq %cl, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x145c0
addq $0x8, %r14
movq %r14, %rdi
callq 0x145bc
movl %ebx, %ecx
shrq %cl, %rax
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x145c0
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x810, %rsp            # imm = 0x810
leaq 0xe05(%rip), %rbx       # 0x205e
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1080
leaq -0xca(%rip), %r15       # 0x11ac
movq %rsp, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1070
leaq 0x410(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1, %ecx
xorl %eax, %eax
callq 0x1080
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1070
movq -0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x1090
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x1090
xorl %eax, %eax
addq $0x810, %rsp            # imm = 0x810
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mijallen[P]SimpleHTTPServer/lib/libyaml/tests/run-parser.c
// Function: main
int
main(int argc, char *argv[])
{
    int number;

    if (argc < 2) {
        printf("Usage: %s file1.yaml ...\n", argv[0]);
        return 0;
    }

    for (number = 1; number < argc; number ++)
    {
        FILE *file;
        yaml_parser_t parser;
        yaml_event_t event;
        int done = 0;
        int count = 0;
        int error = 0;

        printf("[%d] Parsing '%s': ", number, argv[number]);
        fflush(stdout);

        file = fopen(argv[number], "rb");
        assert(file);

        assert(yaml_parser_initialize(&parser));

        yaml_parser_set_input_file(&parser, file);

        while (!done)
        {
            if (!yaml_parser_parse(&parser, &event)) {
                error = 1;
                break;
            }

            done = (event.type == YAML_STREAM_END_EVENT);

            yaml_event_delete(&event);

            count ++;
        }

        yaml_parser_delete(&parser);

        assert(!fclose(file));

        printf("%s (%d events)\n", (error ? "FAILURE" : "SUCCESS"), count);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rsi, %rbx
cmpl $0x2, %edi
jge 0x11fb
movq (%rbx), %rsi
leaq 0xe15(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1060
jmp 0x12f9
movl %edi, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %r14d
leaq 0x88(%rsp), %r13
leaq 0x20(%rsp), %rbp
movq %rbx, 0x10(%rsp)
movq (%rbx,%r14,8), %rdx
leaq 0xdf9(%rip), %rdi       # 0x201e
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
movq 0x2daa(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x10a0
movq (%rbx,%r14,8), %rdi
leaq 0xde9(%rip), %rsi       # 0x2032
callq 0x10b0
testq %rax, %rax
je 0x130d
movq %rax, %r12
movq %r14, 0x18(%rsp)
movq %r13, %rdi
callq 0x1090
testl %eax, %eax
je 0x132c
movq %r13, %rdi
movq %r12, %rsi
callq 0x1030
xorl %r15d, %r15d
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1040
movl %eax, %ebx
testl %eax, %eax
je 0x12a4
movl 0x20(%rsp), %r14d
movq %rbp, %rdi
callq 0x10c0
incl %r15d
cmpl $0x2, %r14d
jne 0x127d
movq %r13, %rdi
callq 0x1080
movq %r12, %rdi
callq 0x1050
testl %eax, %eax
jne 0x134b
testl %ebx, %ebx
leaq 0xddf(%rip), %rsi       # 0x20a4
leaq 0xdd0(%rip), %rax       # 0x209c
cmoveq %rax, %rsi
leaq 0xdb5(%rip), %rdi       # 0x208c
movl %r15d, %edx
xorl %eax, %eax
callq 0x1060
movq 0x18(%rsp), %r14
incq %r14
cmpq 0x8(%rsp), %r14
movq 0x10(%rsp), %rbx
jne 0x121a
xorl %eax, %eax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd21(%rip), %rdi       # 0x2035
leaq 0xd1f(%rip), %rsi       # 0x203a
leaq 0xd25(%rip), %rcx       # 0x2047
movl $0x22, %edx
callq 0x1070
leaq 0xd2b(%rip), %rdi       # 0x205e
leaq 0xd00(%rip), %rsi       # 0x203a
leaq 0xd06(%rip), %rcx       # 0x2047
movl $0x24, %edx
callq 0x1070
leaq 0xd2c(%rip), %rdi       # 0x207e
leaq 0xce1(%rip), %rsi       # 0x203a
leaq 0xce7(%rip), %rcx       # 0x2047
movl $0x38, %edx
callq 0x1070
// File: /workspace/github_c_makefile_star2_O3/fm4dd[P]learn-ssl/keycompare.c
// Function: ECsign
ECDSA_SIG *ECsign(EVP_PKEY *key, const unsigned char *teststring) {
  ECDSA_SIG *sig;

#if OPENSSL_VERSION_NUMBER < 0x30000000L
  EC_KEY *priveckey = NULL;
  priveckey = EVP_PKEY_get1_EC_KEY(key);
  sig = ECDSA_do_sign(teststring, teststr_len, priveckey);
  EC_KEY_free(priveckey);
#else
  EVP_MD_CTX *ctx = NULL;
  ctx = EVP_MD_CTX_new();
  unsigned char *sigstr;
  size_t *sig_len;
  EVP_DigestSign(ctx, sigstr, sig_len, teststring, teststr_len);
  sig = d2i_ECDSA_SIG(NULL, (const unsigned char **) &sigstr, (long) &sig_len);
  EVP_MD_CTX_free(ctx);
#endif
  return sig;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
callq 0x1160
movq %rax, %r14
movslq 0x28bb(%rip), %r8       # 0x413c
movq %rax, %rdi
movq %rbx, %rcx
callq 0x1050
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %edi, %edi
callq 0x10e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x11f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/fm4dd[P]learn-ssl/keycompare.c
// Function: ECverify
int ECverify(EVP_PKEY *key, const unsigned char *teststring, ECDSA_SIG *sig) {

  teststr_len = strlen( (const char *) teststring);
#if OPENSSL_VERSION_NUMBER < 0x30000000L
  EC_KEY *pubeckey = NULL;
  pubeckey = EVP_PKEY_get1_EC_KEY(key);
  ret = ECDSA_do_verify(teststring, teststr_len, sig, pubeckey);
  EC_KEY_free(pubeckey);
#else
  EVP_MD_CTX *ctx = NULL;
  ctx = EVP_MD_CTX_new();
  unsigned char *sigstr;
  i2d_ECDSA_SIG(sig, &sigstr);
  size_t sig_len = strlen( (const char *) sigstr);
  /* ---------------------------------------------------------- *
   * Successful verification returns 1                          *
   * ---------------------------------------------------------- */
    ret = EVP_DigestVerify(ctx, sigstr, sig_len, teststring, teststr_len);
   EVP_MD_CTX_free(ctx);
#endif
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0x10d0
movl %eax, 0x286d(%rip)      # 0x413c
callq 0x1160
movq %rax, %r15
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1170
movq (%r12), %rbx
movq %rbx, %rdi
callq 0x10d0
movslq 0x2844(%rip), %r8       # 0x413c
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x1070
movl %eax, 0x2829(%rip)      # 0x4138
movq %r15, %rdi
callq 0x11f0
movl 0x281b(%rip), %eax      # 0x4138
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/main.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2) return usage();
	if (strcmp(argv[1], "import") == 0) return main_import(argc-1, argv+1);
	else if (strcmp(argv[1], "atomize") == 0) return main_atomize(argc-1, argv+1);
	else if (strcmp(argv[1], "view") == 0 || strcmp(argv[1], "mview") == 0 ) return main_view(argc-1, argv+1);
	else if (strcmp(argv[1], "fmf") == 0 ) return main_fmf(argc-1, argv+1);
	else if (strcmp(argv[1], "getalt") == 0) return main_getalt(argc-1, argv+1);
	else if (strcmp(argv[1], "bcfidx") == 0) return main_bcfidx(argc-1, argv+1);
	else if (strcmp(argv[1], "version") == 0) {
		puts(BGT_VERSION);
		return 0;
	} else {
		fprintf(stderr, "[E::%s] unrecognized command '%s'\n", __func__, argv[1]);
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x2dc6
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
addq $0x8, %rbx
leaq 0x1b327(%rip), %rsi     # 0x1e004
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2d96
leaq 0x1c7fe(%rip), %rsi     # 0x1f4f2
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2db6
leaq 0x1b878(%rip), %rsi     # 0x1e583
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2da6
leaq 0x1b2e9(%rip), %rsi     # 0x1e00b
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2da6
leaq 0x1b2dc(%rip), %rsi     # 0x1e011
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2dd5
leaq 0x1b2c9(%rip), %rsi     # 0x1e015
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2de5
leaq 0x1b2b9(%rip), %rsi     # 0x1e01c
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
je 0x2df5
leaq 0x1b2a9(%rip), %rsi     # 0x1e023
movq %r14, %rdi
callq 0x2230
testl %eax, %eax
jne 0x2e05
leaq 0x1b29e(%rip), %rdi     # 0x1e02b
callq 0x20e0
xorl %eax, %eax
jmp 0x2dd0
decl %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2e2c
decl %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x36bc
decl %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x346a
callq 0x2480
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
decl %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xab5b
decl %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3dfb
decl %ebp
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x33e6
movq 0x231ec(%rip), %rax     # 0x25ff8
movq (%rax), %rdi
leaq 0x1b224(%rip), %rsi     # 0x1e03a
leaq 0x1b240(%rip), %rdx     # 0x1e05d
movq %r14, %rcx
xorl %eax, %eax
callq 0x2250
jmp 0x2dcb
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/import.c
// Function: main_bcfidx
int main_bcfidx(int argc, char *argv[])
{
	int c, min_shift = 14;
	while ((c = getopt(argc, argv, "s:")) >= 0)
		if (c == 's') min_shift = atoi(optarg);
	if (optind == argc) {
		fprintf(stderr, "Usage: bgt bcfidx [-s minShift] <in.bcf>\n");
		return 1;
	}
	bcf_index_build(argv[optind], min_shift);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x1af6a(%rip), %rdx     # 0x1e364
callq 0x23d0
movl $0xe, %r14d
testl %eax, %eax
js 0x3439
movq 0x22ba0(%rip), %r12     # 0x25fb0
leaq 0x1af4d(%rip), %r15     # 0x1e364
cmpl $0x73, %eax
jne 0x3428
movq (%r12), %rdi
callq 0x23e0
movl %eax, %r14d
movl %ebp, %edi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x23d0
testl %eax, %eax
jns 0x3417
movq 0x22b58(%rip), %rax     # 0x25f98
movslq (%rax), %rax
cmpl %ebp, %eax
je 0x345e
movq (%rbx,%rax,8), %rdi
movl %r14d, %esi
callq 0x10ad8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x25d3
movl $0x1, %eax
jmp 0x3455
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/fmf.c
// Function: fmf_destroy
void fmf_destroy(fmf_t *f)
{
	int i;
	if (f == 0) return;
	for (i = 0; i < f->n_keys; ++i) free(f->keys[i]);
	for (i = 0; i < f->n_vals; ++i) free(f->vals[i]);
	for (i = 0; i < f->n_rows; ++i) {
		fmf1_t *r = &f->rows[i];
		free(r->name); free(r->meta);
	}
	free(f->rows); free(f->keys); free(f->vals);
	free(f);
}

// Assembly:
testq %rdi, %rdi
je 0xa20c
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0xa186
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2050
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0xa16e
cmpl $0x0, 0x10(%rbx)
jle 0xa1a8
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2050
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0xa18f
cmpl $0x0, 0x20(%rbx)
jle 0xa1de
movl $0x10, %r14d
xorl %r15d, %r15d
movq 0x28(%rbx), %r12
movq -0x10(%r12,%r14), %rdi
callq 0x2050
movq (%r12,%r14), %rdi
callq 0x2050
incq %r15
movslq 0x20(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0xa1b7
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x8(%rbx), %rdi
callq 0x2050
movq 0x18(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/fmf.c
// Function: fmf_test
int fmf_test(const fmf_t *f, int r, kexpr_t *ke) // FIXME: a quadratic implementation!!! optimize later if too slow
{
	fmf1_t *u;
	int err, i, is_true;
	if (r >= f->n_rows) return 0;
	u = &f->rows[r];
	ke_unset(ke);
	for (i = 0; i < u->n_meta; ++i) {
		fmf_meta_t *m = &u->meta[i];
		ke_set_str(ke, "_ROW_", u->name);
		if (m->type == FMF_STR) ke_set_str(ke, f->keys[m->key], f->vals[m->v.s]);
		else if (m->type == FMF_INT) ke_set_int(ke, f->keys[m->key], m->v.i);
		else if (m->type == FMF_REAL) ke_set_int(ke, f->keys[m->key], m->v.r);
	}
	is_true = !!ke_eval_int(ke, &err);
	return !(err || !is_true);
}

// Assembly:
xorl %eax, %eax
cmpl %esi, 0x20(%rdi)
jle 0xa890
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %r15
movslq %esi, %rax
leaq (%rax,%rax,2), %r12
movq %rdx, %rdi
callq 0x1d667
cmpl $0x0, 0x8(%r15,%r12,8)
jle 0xa860
leaq (%r15,%r12,8), %r12
xorl %r13d, %r13d
leaq 0x14949(%rip), %r15     # 0x1f117
movq (%r12), %rdx
movq 0x10(%r12), %rbp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d2ec
movl (%rbp,%r13,8), %eax
movl %eax, %ecx
shrl $0x1c, %ecx
cmpl $0x1, %ecx
je 0xa835
cmpl $0x2, %ecx
je 0xa81f
cmpl $0x3, %ecx
jne 0xa84f
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movq 0x8(%r14), %rcx
movq 0x18(%r14), %rdx
movq (%rcx,%rax,8), %rsi
movl 0x4(%rbp,%r13,8), %eax
movq (%rdx,%rax,8), %rdx
movq %rbx, %rdi
callq 0x1d2ec
jmp 0xa84f
movq 0x8(%r14), %rcx
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movq (%rcx,%rax,8), %rsi
cvttss2si 0x4(%rbp,%r13,8), %rdx
jmp 0xa847
movq 0x8(%r14), %rcx
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movq (%rcx,%rax,8), %rsi
movslq 0x4(%rbp,%r13,8), %rdx
movq %rbx, %rdi
callq 0x1d157
incq %r13
movslq 0x8(%r12), %rax
cmpq %rax, %r13
jl 0xa7ce
leaq 0x4(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d095
testq %rax, %rax
setne %al
cmpl $0x0, (%r14)
sete %cl
andb %al, %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/fmf.c
// Function: fms_open
fms_t *fms_open(const char *fn)
{
	fms_t *f;
	gzFile fp;
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return 0;
	f = (fms_t*)calloc(1, sizeof(fms_t));
	f->ks = ks_init(fp);
	f->fp = fp;
	return f;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa8b3
cmpb $0x2d, (%rdi)
jne 0xa8a5
cmpb $0x0, 0x1(%rdi)
je 0xa8b3
leaq 0x1499c(%rip), %rsi     # 0x1f248
callq 0x2370
jmp 0xa8d0
movq 0x1b6ce(%rip), %rax     # 0x25f88
movq (%rax), %rdi
callq 0x22a0
leaq 0x1497f(%rip), %rsi     # 0x1f248
movl %eax, %edi
callq 0x2140
movq %rax, %rbx
testq %rax, %rax
je 0xa8fb
movl $0x1, %edi
movl $0x28, %esi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x5c48
movq %rax, (%r14)
movq %rbx, 0x20(%r14)
jmp 0xa8fe
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/fmf.c
// Function: fms_close
void fms_close(fms_t *f)
{
	if (f == 0) return;
	free(f->s.s);
	ks_destroy(f->ks);
	gzclose(f->fp);
	free(f);
}

// Assembly:
testq %rdi, %rdi
je 0xa935
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x2050
movq (%rbx), %rdi
callq 0x5c85
movq 0x20(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
popq %rbx
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/fmf.c
// Function: fms_read
const char *fms_read(fms_t *f, kexpr_t *ke, int name_only)
{
	int ret;
	char *end0 = 0;
	while ((ret = fms_read_and_test(f, ke, &end0)) == 0);
	if (ret < 0) return 0;
	if (name_only) *end0 = 0;
	return f->s.s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, 0x34(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq $0x0, 0x20(%rsp)
leaq 0x18(%rsp), %r15
movl $0x0, 0x1c(%rsp)
movq (%rbx), %rdi
movl $0x2, %esi
movq %r14, %rdx
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x5ca1
testl %eax, %eax
js 0xab35
cmpq $0x0, (%r14)
je 0xa962
movq %r14, 0x38(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xa9ac
movq 0x8(%rsp), %rdi
callq 0x1d667
movq 0x8(%rsp), %rdi
movq %rbx, 0x28(%rsp)
movq 0x18(%rbx), %r12
xorl %ecx, %ecx
movq %r12, %r15
movq %r12, %rbp
movzbl (%rbp), %r14d
cmpl $0x9, %r14d
je 0xa9d1
testl %r14d, %r14d
jne 0xaada
movb $0x0, (%rbp)
testl %ecx, %ecx
je 0xaa55
movq %r12, %rax
subq %r15, %rax
movq %r15, %rbx
movq %rbx, 0x40(%rsp)
movzbl (%rbx), %r13d
testl %r13d, %r13d
je 0xa9fe
cmpl $0x3a, %r13d
je 0xa9fe
incq %rbx
decq %rax
jmp 0xa9e2
movb $0x0, (%rbx)
cmpb $0x3a, %r13b
jne 0xaac8
testq %rdi, %rdi
je 0xaac8
cmpq $0x3, %rax
jl 0xaac8
movzbl 0x1(%rbx), %eax
leaq 0x3(%rbx), %rdx
cmpl $0x66, %eax
movl %ecx, 0x14(%rsp)
je 0xaa8d
cmpl $0x69, %eax
jne 0xaab2
movq %rdx, %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x2270
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1d157
jmp 0xaabf
testq %rdi, %rdi
je 0xaa7e
movq 0x8(%rsp), %rdi
leaq 0x146b1(%rip), %rsi     # 0x1f117
movq %r15, %rdx
movl %ecx, %ebx
callq 0x1d2ec
movl %ebx, %ecx
movq 0x8(%rsp), %rdi
movq %rbp, 0x20(%rsp)
jmp 0xaacb
movq %rbp, 0x20(%rsp)
testb %r14b, %r14b
jne 0xaad0
jmp 0xab22
movq %rdx, %rdi
leaq 0x40(%rsp), %rsi
callq 0x2100
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d21a
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rdi
jmp 0xaac8
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d2ec
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %ecx
movb %r13b, (%rbx)
testb %r14b, %r14b
je 0xaae5
incl %ecx
leaq 0x1(%rbp), %r15
movb %r14b, (%rbp)
incq %rbp
incq %r12
jmp 0xa9bd
testq %rdi, %rdi
movq 0x38(%rsp), %r14
je 0xab01
leaq 0x1c(%rsp), %rsi
callq 0x1d095
testq %rax, %rax
setne %al
jmp 0xab03
movb $0x1, %al
movq 0x28(%rsp), %rbx
leaq 0x18(%rsp), %r15
cmpl $0x0, 0x1c(%rsp)
jne 0xa962
testb %al, %al
je 0xa962
jmp 0xab46
movb $0x1, %al
movq %rbp, 0x20(%rsp)
movq 0x28(%rsp), %rbx
movq 0x38(%rsp), %r14
jmp 0xab08
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x34(%rsp)
je 0xab55
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rbx), %rax
jmp 0xab37
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/fmf.c
// Function: main_fmf
int main_fmf(int argc, char *argv[])
{
	kexpr_t *ke = 0;
	int i, c, err, in_mem = 0, name_only = 0;
	while ((c = getopt(argc, argv, "mn")) >= 0)
		if (c == 'm') in_mem = 1;
		else if (c == 'n') name_only = 1;
	if (argc == optind) {
		fprintf(stderr, "Usage: fmf [-mn] <in.fmf> [condition]\n");
		fprintf(stderr, "Options:\n");
		fprintf(stderr, "  -m   load the entire FMF into RAM\n");
		fprintf(stderr, "  -n   only output the row name (the 1st column)\n");
		return 1;
	}
	if (argc - optind >= 2) ke = ke_parse(argv[optind+1], &err);
	if (in_mem) {
		fmf_t *f;
		f = fmf_read(argv[optind]);
		for (i = 0; i < f->n_rows; ++i) {
			char *s;
			if (ke && !fmf_test(f, i, ke)) continue;
			if (!name_only) {
				s = fmf_write(f, i);
				puts(s);
				free(s);
			} else puts(f->rows[i].name);
		}
		fmf_destroy(f);
	} else {
		fms_t *f;
		const char *s;
		f = fms_open(argv[optind]);
		while ((s = fms_read(f, ke, name_only)) != 0)
			puts(s);
		fms_close(f);
	}
	if (ke) ke_destroy(ke);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movl %edi, %ebp
leaq 0x145a8(%rip), %rdx     # 0x1f11d
callq 0x23d0
testl %eax, %eax
js 0xabb9
xorl %ebx, %ebx
leaq 0x14596(%rip), %r14     # 0x1f11d
xorl %r13d, %r13d
cmpl $0x6d, %eax
je 0xab9c
cmpl $0x6e, %eax
jne 0xaba1
movl $0x1, %r13d
jmp 0xaba1
movl $0x1, %ebx
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x23d0
testl %eax, %eax
jns 0xab8a
testl %ebx, %ebx
sete %bl
jmp 0xabbe
movb $0x1, %bl
xorl %r13d, %r13d
movq 0x1b3d3(%rip), %r12     # 0x25f98
movslq (%r12), %rax
cmpl %eax, %ebp
je 0xacda
subl %eax, %ebp
cmpl $0x2, %ebp
jl 0xabec
movq 0x8(%r15,%rax,8), %rdi
leaq 0x14(%rsp), %rsi
callq 0x1bb84
movq %rax, %r14
jmp 0xabef
xorl %r14d, %r14d
movslq (%r12), %rax
movq (%r15,%rax,8), %rdi
testb %bl, %bl
je 0xac27
callq 0xa891
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0xa936
testq %rax, %rax
je 0xacb2
movq %rax, %rdi
callq 0x20e0
movq %r15, %rdi
jmp 0xac06
callq 0x9c9c
movq %rax, %r15
movslq 0x20(%rax), %rbp
testq %rbp, %rbp
jle 0xaca8
xorl %ebx, %ebx
xorl %r12d, %r12d
movq %r15, 0x8(%rsp)
testq %r14, %r14
je 0xac59
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0xa785
testl %eax, %eax
je 0xac9c
testl %r13d, %r13d
je 0xac6d
movq 0x28(%r15), %rax
movq (%rax,%rbx), %rdi
callq 0x20e0
jmp 0xac9c
movq %r15, %rdi
movl %r12d, %esi
callq 0xa20d
movq %rbp, %r15
movl %r13d, %ebp
movq %rax, %r13
movq %rax, %rdi
callq 0x20e0
movq %r13, %rdi
movl %ebp, %r13d
movq %r15, %rbp
movq 0x8(%rsp), %r15
callq 0x2050
incq %r12
addq $0x18, %rbx
cmpq %rbp, %r12
jb 0xac42
movq %r15, %rdi
callq 0xa152
jmp 0xacba
movq %r15, %rdi
callq 0xa909
xorl %ebx, %ebx
testq %r14, %r14
je 0xacc9
movq %r14, %rdi
callq 0x1d0fd
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2af6
movl $0x1, %ebx
jmp 0xacc9
nop
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/vcf.c
// Function: bcf_hdr_sync
int bcf_hdr_sync(bcf_hdr_t *h)
{
	int i;
	for (i = 0; i < 3; ++i) {
		khint_t k;
		vdict_t *d = (vdict_t*)h->dict[i];
		h->n[i]  = kh_size(d);
		h->id[i] = (bcf_idpair_t*)realloc(h->id[i], kh_size(d) * sizeof(bcf_idpair_t));
		for (k = kh_begin(d); k != kh_end(d); ++k) {
			if (!kh_exist(d, k)) continue;
			h->id[i][kh_val(d, k).id].key = kh_key(d, k);
			h->id[i][kh_val(d, k).id].val = &kh_val(d, k);
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x30(%rbx,%r14,8), %r15
movl 0x4(%r15), %esi
movl %esi, 0x8(%rbx,%r14,4)
movq 0x18(%rbx,%r14,8), %rdi
shlq $0x4, %rsi
callq 0x2330
movq %rax, 0x18(%rbx,%r14,8)
movl (%r15), %eax
testq %rax, %rax
je 0xb782
movq 0x10(%r15), %rdx
movl $0xc, %esi
xorl %edi, %edi
xorl %r8d, %r8d
movl %r8d, %ecx
shrl $0x4, %ecx
movl (%rdx,%rcx,4), %r9d
movl %edi, %ecx
andb $0x1e, %cl
shrl %cl, %r9d
testb $0x3, %r9b
jne 0xb773
movq 0x18(%r15), %rcx
movq 0x20(%r15), %r9
movq (%rcx,%r8,8), %rcx
movq 0x18(%rbx,%r14,8), %r10
addq %rsi, %r9
addq $-0xc, %r9
movslq 0xc(%r9), %r11
shlq $0x4, %r11
movq %rcx, (%r10,%r11)
movq 0x18(%rbx,%r14,8), %rcx
movq %r9, 0x8(%rcx,%r11)
incq %r8
addq $0x10, %rsi
addl $0x2, %edi
cmpq %r8, %rax
jne 0xb72d
incq %r14
cmpq $0x3, %r14
jne 0xb6f6
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/vcf.c
// Function: bcf_hdr_parse
int bcf_hdr_parse(bcf_hdr_t *h)
{
	char *p, *q;
	bcf_hdr_parse1(h, "##FILTER=<ID=PASS,Description=\"All filters passed\">"); // add PASS before anything else
	for (p = q = h->text; q - h->text < h->l_text; ++q) {
		int c;
		if (*q != '\n' && *q != 0) continue;
		c = *q; *q = 0;
		bcf_hdr_parse1(h, p);
		*q = c;
		if (*q == 0) break;
		p = q + 1;
	}
	bcf_hdr_sync(h);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x13b66(%rip), %rsi     # 0x1f30e
callq 0xb275
movl (%rbx), %eax
testl %eax, %eax
jle 0xb802
movq 0x48(%rbx), %r14
leaq 0x1(%r14), %r15
movq %r14, %rcx
movq %r14, %rsi
movzbl -0x1(%r15), %ebp
cmpl $0xa, %ebp
je 0xb7cf
testl %ebp, %ebp
jne 0xb7ee
movb $0x0, -0x1(%r15)
movq %rbx, %rdi
callq 0xb275
movb %bpl, -0x1(%r15)
testb %bpl, %bpl
je 0xb802
movq 0x48(%rbx), %rcx
movl (%rbx), %eax
movq %r15, %rsi
movslq %eax, %rdx
incq %r15
incq %r14
movq %r14, %rdi
subq %rcx, %rdi
cmpq %rdx, %rdi
jl 0xb7c1
movq %rbx, %rdi
callq 0xb6eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/vcf.c
// Function: bcf_hdr_append
int bcf_hdr_append(bcf_hdr_t *h, const char *line)
{
	int len, i;
	len = strlen(line);
	if (line[len - 1] == '\n') --len;
	if (h->m_text < h->l_text + len + 1) {
		h->m_text = h->l_text + len + 1;
		kroundup32(h->m_text);
		h->text = (char*)realloc(h->text, h->m_text);
	}
	for (i = h->l_text - 1; i >= 0; --i)
		if (h->text[i] == '#' && (i == 0 || h->text[i-1] == '\n'))
			break;
	if (i < 0) return -1; // no #CHROM line
	memmove(&h->text[i+len+1], &h->text[i], h->l_text - i);
	memcpy(&h->text[i], line, len);
	h->text[i+len] = '\n';
	h->l_text += len;
	bcf_hdr_parse1(h, line);
	bcf_hdr_sync(h);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2170
movq %rax, %r15
decl %eax
cltq
xorl %ebp, %ebp
cmpb $0xa, (%r14,%rax)
sete %bpl
movl %r15d, %r12d
subl %ebp, %r12d
movl (%rbx), %ecx
leal (%r12,%rcx), %eax
cmpl %eax, 0x4(%rbx)
jg 0xb889
movl %eax, %ecx
sarl %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
sarl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
sarl $0x10, %ecx
orl %eax, %ecx
incl %ecx
movl %ecx, 0x4(%rbx)
movq 0x48(%rbx), %rdi
movslq %ecx, %rsi
callq 0x2330
movq %rax, 0x48(%rbx)
movl (%rbx), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0xb934
negl %ebp
movq 0x48(%rbx), %rsi
movl %ecx, %r8d
leaq (%r8,%rsi), %rdi
decq %rdi
xorl %edx, %edx
leaq (%r8,%rdx), %r9
decq %r9
cmpb $0x23, (%rdi,%rdx)
jne 0xb8c1
testq %r9, %r9
je 0xb8cf
cmpb $0xa, -0x1(%rdi,%rdx)
je 0xb8cf
decq %rdx
incq %r9
cmpq $0x1, %r9
ja 0xb8a8
jmp 0xb934
addl %ebp, %ecx
addl %r15d, %ecx
movl %ecx, %eax
addl %edx, %eax
leal (%rdx,%rcx), %ebp
decl %ebp
movslq %eax, %rdi
addq %rsi, %rdi
leal (%r8,%rdx), %r15d
decl %r15d
addq %r15, %rsi
movl $0x1, %eax
subl %edx, %eax
movslq %eax, %rdx
callq 0x2360
addq 0x48(%rbx), %r15
movslq %r12d, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2280
movq 0x48(%rbx), %rax
movslq %ebp, %rcx
movb $0xa, (%rax,%rcx)
addl %r12d, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb275
movq %rbx, %rdi
callq 0xb6eb
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq