LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: generateFixedLitLenTree(HuffmanTree*)
static unsigned generateFixedLitLenTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DEFLATE_CODE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*288 possible codes: 0-255=literals, 256=endcode, 257-285=lengthcodes, 286-287=unused*/
  for(i =   0; i <= 143; ++i) bitlen[i] = 8;
  for(i = 144; i <= 255; ++i) bitlen[i] = 9;
  for(i = 256; i <= 279; ++i) bitlen[i] = 7;
  for(i = 280; i <= 287; ++i) bitlen[i] = 8;

  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DEFLATE_CODE_SYMBOLS, 15);

  lodepng_free(bitlen);
  return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x480, %edi            # imm = 0x480
callq 0x21e0
testq %rax, %rax
je 0xda45
vbroadcastss 0x49a9(%rip), %zmm0 # 0x1231c
movq %rax, %rbx
xorl %eax, %eax
vmovups %zmm0, (%rbx,%rax,4)
addq $0x10, %rax
cmpq $0x90, %rax
jne 0xd978
vbroadcastss 0x498b(%rip), %zmm0 # 0x12320
movl $0x90, %eax
vmovups %zmm0, (%rbx,%rax,4)
addq $0x10, %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0xd99a
vpmovsxbq 0x4849(%rip), %zmm0 # 0x12200
vpmovsxbq 0x482f(%rip), %zmm1 # 0x121f0
vpbroadcastq 0x4815(%rip), %zmm2 # 0x121e0
vpbroadcastd 0x493b(%rip), %zmm3 # 0x12310
xorl %eax, %eax
vpbroadcastq %rax, %zmm4
vporq %zmm0, %zmm4, %zmm5
vporq %zmm1, %zmm4, %zmm4
vpcmpltuq %zmm2, %zmm4, %k0
vpcmpltuq %zmm2, %zmm5, %k1
kunpckbw %k0, %k1, %k1
vmovdqu32 %zmm3, 0x400(%rbx,%rax,4) {%k1}
addq $0x10, %rax
cmpq $0x20, %rax
jne 0xd9d7
vbroadcastss 0x4906(%rip), %ymm0 # 0x1231c
movl $0x120, %edx            # imm = 0x120
movl $0xf, %ecx
movq %r14, %rdi
movq %rbx, %rsi
vmovups %ymm0, 0x460(%rbx)
vzeroupper
callq 0xdaac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: generateFixedDistanceTree(HuffmanTree*)
static unsigned generateFixedDistanceTree(HuffmanTree* tree)
{
  unsigned i, error = 0;
  unsigned* bitlen = (unsigned*)lodepng_malloc(NUM_DISTANCE_SYMBOLS * sizeof(unsigned));
  if(!bitlen) return 83; /*alloc fail*/

  /*there are 32 distance codes, but 30-31 are unused*/
  for(i = 0; i != NUM_DISTANCE_SYMBOLS; ++i) bitlen[i] = 5;
  error = HuffmanTree_makeFromLengths(tree, bitlen, NUM_DISTANCE_SYMBOLS, 15);

  lodepng_free(bitlen);
  return error;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x80, %edi
callq 0x21e0
testq %rax, %rax
je 0xdaa4
vbroadcastss 0x48b7(%rip), %zmm0 # 0x12324
movl $0x20, %edx
movl $0xf, %ecx
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
vmovups %zmm0, (%rax)
vmovups %zmm0, 0x40(%rax)
vzeroupper
callq 0xdaac
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: HuffmanTree_makeFromLengths(HuffmanTree*, unsigned int const*, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromLengths(HuffmanTree* tree, const unsigned* bitlen,
                                            size_t numcodes, unsigned maxbitlen)
{
  unsigned i;
  tree->lengths = (unsigned*)lodepng_malloc(numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  for(i = 0; i != numcodes; ++i) tree->lengths[i] = bitlen[i];
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->maxbitlen = maxbitlen;
  return HuffmanTree_makeFromLengths2(tree);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq (,%rdx,4), %rdi
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
callq 0x21e0
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0xdb05
testq %r15, %r15
je 0xdaed
xorl %ecx, %ecx
movl (%r12,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
movl %ecx, %edx
cmpq %r15, %rdx
jne 0xdadc
movl %r15d, 0x1c(%r14)
movl %ebx, 0x18(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xdb16
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: writeLZ77data(unsigned long*, ucvector*, uivector const*, HuffmanTree const*, HuffmanTree const*)
static void writeLZ77data(size_t* bp, ucvector* out, const uivector* lz77_encoded,
                          const HuffmanTree* tree_ll, const HuffmanTree* tree_d)
{
  size_t i = 0;
  for(i = 0; i != lz77_encoded->size; ++i)
  {
    unsigned val = lz77_encoded->data[i];
    addHuffmanSymbol(bp, out, HuffmanTree_getCode(tree_ll, val), HuffmanTree_getLength(tree_ll, val));
    if(val > 256) /*for a length code, 3 more things have to be added*/
    {
      unsigned length_index = val - FIRST_LENGTH_CODE_INDEX;
      unsigned n_length_extra_bits = LENGTHEXTRA[length_index];
      unsigned length_extra_bits = lz77_encoded->data[++i];

      unsigned distance_code = lz77_encoded->data[++i];

      unsigned distance_index = distance_code;
      unsigned n_distance_extra_bits = DISTANCEEXTRA[distance_index];
      unsigned distance_extra_bits = lz77_encoded->data[++i];

      addBitsToStream(bp, out, length_extra_bits, n_length_extra_bits);
      addHuffmanSymbol(bp, out, HuffmanTree_getCode(tree_d, distance_code),
                       HuffmanTree_getLength(tree_d, distance_code));
      addBitsToStream(bp, out, distance_extra_bits, n_distance_extra_bits);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, 0x8(%rdx)
movq %r8, 0x8(%rsp)
je 0xe6b6
movq %rcx, %rbp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %r14d, %r14d
movq (%r15), %rax
movq 0x8(%rbp), %rsi
movq 0x10(%rbp), %rcx
movq %r13, %rdi
movl (%rax,%r14,4), %ebx
movl (%rsi,%rbx,4), %edx
movl (%rcx,%rbx,4), %ecx
movq %r12, %rsi
callq 0xe6c5
cmpq $0x101, %rbx            # imm = 0x101
jb 0xe6a9
addl $0xfffffeff, %ebx       # imm = 0xFFFFFEFF
leaq 0x37a6(%rip), %rax      # 0x11de0
leaq 0x389f(%rip), %rsi      # 0x11ee0
movq %r13, %rdi
movl (%rax,%rbx,4), %ecx
movq (%r15), %rax
movq %rbp, %rbx
movl 0x8(%rax,%r14,4), %ebp
movl 0x4(%rax,%r14,4), %edx
movl 0xc(%rax,%r14,4), %eax
addq $0x3, %r14
movl (%rsi,%rbp,4), %esi
movl %eax, 0x4(%rsp)
movq %rsi, 0x10(%rsp)
movq %r12, %rsi
callq 0xe84a
movq 0x8(%rsp), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
movl (%rax,%rbp,4), %edx
movl (%rcx,%rbp,4), %ecx
movq %rbx, %rbp
callq 0xe6c5
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rcx
movq %r13, %rdi
movq %r12, %rsi
callq 0xe84a
incq %r14
cmpq 0x8(%r15), %r14
jne 0xe604
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: getHash(unsigned char const*, unsigned long, unsigned long)
static unsigned getHash(const unsigned char* data, size_t size, size_t pos)
{
  unsigned result = 0;
  if(pos + 2 < size)
  {
    /*A simple shift and xor hash is used. Since the data of PNGs is dominated
    by zeroes due to the filters, a better hash does not have a significant
    effect on speed in traversing the chain, and causes more time spend on
    calculating the hash.*/
    result ^= (unsigned)(data[pos + 0] << 0u);
    result ^= (unsigned)(data[pos + 1] << 4u);
    result ^= (unsigned)(data[pos + 2] << 8u);
  } else {
    size_t amount, i;
    if(pos >= size) return 0;
    amount = size - pos;
    for(i = 0; i != amount; ++i) result ^= (unsigned)(data[pos + i] << (i * 8u));
  }
  return result & HASH_BIT_MASK;
}

// Assembly:
leaq 0x2(%rdx), %rax
cmpq %rsi, %rax
jae 0xe766
movzbl 0x1(%rdi,%rdx), %ecx
movzbl (%rdi,%rdx), %eax
shll $0x4, %ecx
xorl %eax, %ecx
movzbl 0x2(%rdi,%rdx), %eax
shll $0x8, %eax
xorl %ecx, %eax
jmp 0xe843
xorl %eax, %eax
subq %rdx, %rsi
jbe 0xe846
vpmovsxbq 0x3a85(%rip), %zmm1 # 0x12200
vpmovsxbq 0x3a6b(%rip), %zmm2 # 0x121f0
vpmovsxbd 0x3b71(%rip), %zmm3 # 0x12300
vpbroadcastq 0x3a5f(%rip), %zmm4 # 0x121f8
vpbroadcastd 0x3b89(%rip), %zmm5 # 0x1232c
leaq 0xf(%rsi), %rax
decq %rsi
addq %rdx, %rdi
vpxor %xmm7, %xmm7, %xmm7
xorl %ecx, %ecx
andq $-0x10, %rax
vpbroadcastq %rsi, %zmm0
vpcmpleuq %zmm0, %zmm2, %k0
vpcmpleuq %zmm0, %zmm1, %k1
vmovdqa64 %zmm7, %zmm6
vpslld $0x3, %zmm3, %zmm8
vpaddq %zmm4, %zmm2, %zmm2
vpaddq %zmm4, %zmm1, %zmm1
vpaddd %zmm5, %zmm3, %zmm3
kunpckbw %k0, %k1, %k1
vmovdqu8 (%rdi,%rcx), %xmm7 {%k1} {z}
addq $0x10, %rcx
vpmovzxbd %xmm7, %zmm7    # zmm7 = xmm7[0],zero,zero,zero,xmm7[1],zero,zero,zero,xmm7[2],zero,zero,zero,xmm7[3],zero,zero,zero,xmm7[4],zero,zero,zero,xmm7[5],zero,zero,zero,xmm7[6],zero,zero,zero,xmm7[7],zero,zero,zero,xmm7[8],zero,zero,zero,xmm7[9],zero,zero,zero,xmm7[10],zero,zero,zero,xmm7[11],zero,zero,zero,xmm7[12],zero,zero,zero,xmm7[13],zero,zero,zero,xmm7[14],zero,zero,zero,xmm7[15],zero,zero,zero
vpsllvd %zmm8, %zmm7, %zmm7
vpxord %zmm6, %zmm7, %zmm7
cmpq %rcx, %rax
jne 0xe7bd
vmovdqa32 %zmm7, %zmm6 {%k1}
vextracti64x4 $0x1, %zmm6, %ymm0
vpxord %zmm0, %zmm6, %zmm0
vextracti128 $0x1, %ymm0, %xmm1
vpxor %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpxor %xmm1, %xmm0, %xmm0
vpshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
vpxor %xmm1, %xmm0, %xmm0
vmovd %xmm0, %eax
movzwl %ax, %eax
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: HuffmanTree_makeFromFrequencies(HuffmanTree*, unsigned int const*, unsigned long, unsigned long, unsigned int)
static unsigned HuffmanTree_makeFromFrequencies(HuffmanTree* tree, const unsigned* frequencies,
                                                size_t mincodes, size_t numcodes, unsigned maxbitlen)
{
  unsigned error = 0;
  while(!frequencies[numcodes - 1] && numcodes > mincodes) --numcodes; /*trim zeroes*/
  tree->maxbitlen = maxbitlen;
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/
  tree->lengths = (unsigned*)lodepng_realloc(tree->lengths, numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  /*initialize all lengths to 0*/
  memset(tree->lengths, 0, numcodes * sizeof(unsigned));

  error = lodepng_huffman_code_lengths(tree->lengths, frequencies, numcodes, maxbitlen);
  if(!error) error = HuffmanTree_makeFromLengths2(tree);
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
leaq 0x4(,%rcx,4), %rsi
movl $0x1, %eax
movq %rcx, %r14
movl %r8d, %ebp
movq %rdi, %rbx
xorl %ecx, %ecx
leaq (%r14,%rcx), %rdi
leaq -0x4(%rsi), %r12
decq %rax
cmpq %rdx, %rdi
jbe 0xe918
decq %rcx
cmpl $0x0, -0x8(%r15,%rsi)
movq %r12, %rsi
je 0xe8fa
addq %rax, %r14
movl %ebp, 0x18(%rbx)
movq %r12, %rsi
movl %r14d, 0x1c(%rbx)
movq 0x10(%rbx), %rdi
callq 0x2260
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xe971
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20b0
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x41f8
testl %eax, %eax
jne 0xe976
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdb16
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addColorBits(unsigned char*, unsigned long, unsigned int, unsigned int)
static void addColorBits(unsigned char* out, size_t index, unsigned bits, unsigned in)
{
  unsigned m = bits == 1 ? 7 : bits == 2 ? 3 : 1; /*8 / bits - 1*/
  /*p = the partial index in the byte, e.g. with 4 palettebits it is 0 for first half or 1 for second half*/
  unsigned p = index & m;
  in &= (1u << bits) - 1u; /*filter out any other bits of the input value*/
  in = in << (bits * (m - p));
  if(p == 0) out[index * bits / 8] = in;
  else out[index * bits / 8] |= in;
}

// Assembly:
xorl %eax, %eax
cmpl $0x2, %edx
movl $0x7, %r8d
movl %esi, %r9d
sete %al
cmpl $0x1, %edx
leal 0x1(%rax,%rax), %eax
cmovnel %eax, %r8d
bzhil %edx, %ecx, %eax
movl %edx, %ecx
imulq %rsi, %rcx
andl %r8d, %r9d
subl %r9d, %r8d
imull %edx, %r8d
shrq $0x3, %rcx
shlxl %r8d, %eax, %eax
testl %r9d, %r9d
je 0xe9c8
orb %al, (%rdi,%rcx)
retq
movb %al, (%rdi,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: color_tree_get(ColorTree*, unsigned char, unsigned char, unsigned char, unsigned char)
static int color_tree_get(ColorTree* tree, unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  int bit = 0;
  for(bit = 0; bit < 8; ++bit)
  {
    int i = 8 * ((r >> bit) & 1) + 4 * ((g >> bit) & 1) + 2 * ((b >> bit) & 1) + 1 * ((a >> bit) & 1);
    if(!tree->children[i]) return -1;
    else tree = tree->children[i];
  }
  return tree ? tree->index : -1;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
shrxl %eax, %edx, %r10d
shrxl %eax, %r8d, %ebx
shrxl %eax, %esi, %r9d
shrxl %eax, %ecx, %r11d
andl $0x1, %r10d
andl $0x1, %ebx
andl $0x1, %r9d
andl $0x1, %r11d
leal (%rbx,%r10,4), %r10d
leal (%r10,%r9,8), %r9d
leal (%r9,%r11,2), %r9d
movq (%rdi,%r9,8), %rdi
testq %rdi, %rdi
je 0xea16
incl %eax
cmpl $0x8, %eax
jne 0xe9cf
movl 0x80(%rdi), %eax
jmp 0xea1b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_bKGD(LodePNGInfo*, unsigned char const*, unsigned long)
static unsigned readChunk_bKGD(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(info->color.colortype == LCT_PALETTE)
  {
    /*error: this chunk must be 1 byte for indexed color image*/
    if(chunkLength != 1) return 43;

    info->background_defined = 1;
    info->background_r = info->background_g = info->background_b = data[0];
  }
  else if(info->color.colortype == LCT_GREY || info->color.colortype == LCT_GREY_ALPHA)
  {
    /*error: this chunk must be 2 bytes for greyscale image*/
    if(chunkLength != 2) return 44;

    info->background_defined = 1;
    info->background_r = info->background_g = info->background_b = 256u * data[0] + data[1];
  }
  else if(info->color.colortype == LCT_RGB || info->color.colortype == LCT_RGBA)
  {
    /*error: this chunk must be 6 bytes for greyscale image*/
    if(chunkLength != 6) return 45;

    info->background_defined = 1;
    info->background_r = 256u * data[0] + data[1];
    info->background_g = 256u * data[2] + data[3];
    info->background_b = 256u * data[4] + data[5];
  }

  return 0; /* OK */
}

// Assembly:
movl 0x10(%rdi), %ecx
xorl %eax, %eax
cmpq $0x6, %rcx
ja 0xeab6
leaq 0x2e0d(%rip), %r8       # 0x11840
movslq (%r8,%rcx,4), %rcx
addq %r8, %rcx
jmpq *%rcx
movl $0x2c, %eax
cmpq $0x2, %rdx
jne 0xeab6
movl $0x1, 0x38(%rdi)
movbew (%rsi), %ax
movzwl %ax, %eax
jmp 0xeaa6
movl $0x2d, %eax
cmpq $0x6, %rdx
jne 0xeab6
movl $0x1, 0x38(%rdi)
movl $0x44, %ecx
movbew (%rsi), %ax
movzwl %ax, %eax
movl %eax, 0x3c(%rdi)
movbew 0x2(%rsi), %ax
movzwl %ax, %eax
movl %eax, 0x40(%rdi)
movbew 0x4(%rsi), %ax
movzwl %ax, %eax
jmp 0xeab1
movl $0x2b, %eax
cmpq $0x1, %rdx
jne 0xeab6
movl $0x1, 0x38(%rdi)
movzbl (%rsi), %eax
movl %eax, 0x44(%rdi)
movl %eax, 0x40(%rdi)
movl $0x3c, %ecx
movl %eax, (%rdi,%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_tEXt(LodePNGInfo*, unsigned char const*, unsigned long)
static unsigned readChunk_tEXt(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  unsigned error = 0;
  char *key = 0, *str = 0;
  unsigned i;

  while(!error) /*not really a while loop, only used to break on error*/
  {
    unsigned length, string2_begin;

    length = 0;
    while(length < chunkLength && data[length] != 0) ++length;
    /*even though it's not allowed by the standard, no error is thrown if
    there's no null termination char, if the text is empty*/
    if(length < 1 || length > 79) CERROR_BREAK(error, 89); /*keyword too short or long*/

    key = (char*)lodepng_malloc(length + 1);
    if(!key) CERROR_BREAK(error, 83); /*alloc fail*/

    key[length] = 0;
    for(i = 0; i != length; ++i) key[i] = (char)data[i];

    string2_begin = length + 1; /*skip keyword null terminator*/

    length = chunkLength < string2_begin ? 0 : chunkLength - string2_begin;
    str = (char*)lodepng_malloc(length + 1);
    if(!str) CERROR_BREAK(error, 83); /*alloc fail*/

    str[length] = 0;
    for(i = 0; i != length; ++i) str[i] = (char)data[string2_begin + i];

    error = lodepng_add_text(info, key, str);

    break;
  }

  lodepng_free(key);
  lodepng_free(str);

  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x59, %r14d
xorl %ebx, %ebx
testq %rdx, %rdx
je 0xeaf8
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
cmpb $0x0, (%r15,%rbx)
je 0xeae6
incl %ebx
cmpq %r13, %rbx
jb 0xead8
leal -0x50(%rbx), %eax
cmpl $-0x4f, %eax
jae 0xeb00
xorl %r12d, %r12d
xorl %ebx, %ebx
jmp 0xeb85
xorl %r12d, %r12d
jmp 0xeb85
leal 0x1(%rbx), %r14d
movq %r14, %rdi
callq 0x21e0
testq %rax, %rax
je 0xeb7a
movq %rax, %r12
movq %rbp, (%rsp)
movb $0x0, (%rax,%rbx)
movl %ebx, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2100
xorl %eax, %eax
movq %r13, %rbp
subq %r14, %rbp
cmovbq %rax, %rbp
leal 0x1(%rbp), %edi
callq 0x21e0
testq %rax, %rax
je 0xeb7d
movq %rax, %rbx
movl %ebp, %eax
movb $0x0, (%rbx,%rax)
cmpq %r13, %r14
jae 0xeb66
movl %ebp, %eax
xorl %ecx, %ecx
leal (%r14,%rcx), %edx
movb (%r15,%rdx), %dl
movb %dl, (%rbx,%rcx)
incq %rcx
cmpl %ecx, %eax
jne 0xeb54
movq (%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x7892
movl %eax, %r14d
jmp 0xeb85
xorl %r12d, %r12d
xorl %ebx, %ebx
movl $0x53, %r14d
movq %r12, %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x21b0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: readChunk_pHYs(LodePNGInfo*, unsigned char const*, unsigned long)
static unsigned readChunk_pHYs(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
  if(chunkLength != 9) return 74; /*invalid pHYs chunk size*/

  info->phys_defined = 1;
  info->phys_x = 16777216u * data[0] + 65536u * data[1] + 256u * data[2] + data[3];
  info->phys_y = 16777216u * data[4] + 65536u * data[5] + 256u * data[6] + data[7];
  info->phys_unit = data[8];

  return 0; /* OK */
}

// Assembly:
movl $0x4a, %eax
cmpq $0x9, %rdx
jne 0xf061
movl $0x1, 0xa4(%rdi)
movl (%rsi), %eax
movbel %eax, 0xa8(%rdi)
movl 0x4(%rsi), %eax
movbel %eax, 0xac(%rdi)
movzbl 0x8(%rsi), %eax
movl %eax, 0xb0(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: lodepng_get_raw_size_idat(unsigned int, unsigned int, LodePNGColorMode const*)
static size_t lodepng_get_raw_size_idat(unsigned w, unsigned h, const LodePNGColorMode* color)
{
  /*will not overflow for any color type if roughly w * h < 268435455*/
  size_t bpp = lodepng_get_bpp(color);
  size_t line = ((w / 8) * bpp) + ((w & 7) * bpp + 7) / 8;
  return h * line;
}

// Assembly:
xorl %eax, %eax
cmpl $0x6, %edx
ja 0xf076
leaq 0x3154(%rip), %r8       # 0x121c4
movl %edx, %eax
movl (%r8,%rax,4), %eax
imull %ecx, %eax
movl %edi, %ecx
andl $0x7, %edi
shrl $0x3, %ecx
imulq %rax, %rdi
imulq %rax, %rcx
movl %esi, %eax
addq $0x7, %rdi
shrq $0x3, %rdi
addq %rcx, %rdi
imulq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: removePaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int)
static void removePaddingBits(unsigned char* out, const unsigned char* in,
                              size_t olinebits, size_t ilinebits, unsigned h)
{
  /*
  After filtering there are still padding bits if scanlines have non multiple of 8 bit amounts. They need
  to be removed (except at last scanline of (Adam7-reduced) image) before working with pure image buffers
  for the Adam7 code, the color convert code and the output to the user.
  in and out are allowed to be the same buffer, in may also be higher but still overlapping; in must
  have >= ilinebits*h bits, out must have >= olinebits*h bits, olinebits must be <= ilinebits
  also used to move bits after earlier such operations happened, e.g. in a sequence of reduced images from Adam7
  only useful if (ilinebits - olinebits) is a value in the range 1..7
  */
  unsigned y;
  size_t diff = ilinebits - olinebits;
  size_t ibp = 0, obp = 0; /*input and output bit pointers*/
  for(y = 0; y < h; ++y)
  {
    size_t x;
    for(x = 0; x < olinebits; ++x)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    ibp += diff;
  }
}

// Assembly:
testl %r8d, %r8d
je 0xf459
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rax
subq %rdx, %rax
xorl %r9d, %r9d
xorl %r11d, %r11d
xorl %r10d, %r10d
testq %rdx, %rdx
je 0xf444
leaq (%r11,%rdx), %rbx
movq %rdx, %r14
movq %r10, %r15
movq %r15, %rcx
shrq $0x3, %rcx
movl %r15d, %ebp
movzbl (%rsi,%rcx), %r12d
movl %r11d, %ecx
notb %bpl
movzbl %bpl, %r13d
notb %cl
movb $0x1, %bpl
andb $0x7, %cl
andl $0x7, %r13d
shlb %cl, %bpl
btl %r13d, %r12d
jae 0xf425
movq %r11, %rcx
shrq $0x3, %rcx
orb %bpl, (%rdi,%rcx)
jmp 0xf433
movq %r11, %rcx
notb %bpl
shrq $0x3, %rcx
andb %bpl, (%rdi,%rcx)
incq %r11
incq %r15
decq %r14
jne 0xf3ea
addq %rdx, %r10
movq %rbx, %r11
addq %rax, %r10
incl %r9d
cmpl %r8d, %r9d
jne 0xf3db
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: Adam7_getpassvalues(unsigned int*, unsigned int*, unsigned long*, unsigned long*, unsigned long*, unsigned int, unsigned int, unsigned int)
static void Adam7_getpassvalues(unsigned passw[7], unsigned passh[7], size_t filter_passstart[8],
                                size_t padded_passstart[8], size_t passstart[8], unsigned w, unsigned h, unsigned bpp)
{
  /*the passstart values have 8 values: the 8th one indicates the byte after the end of the 7th (= last) pass*/
  unsigned i;

  /*calculate width and height in pixels of each pass*/
  for(i = 0; i != 7; ++i)
  {
    passw[i] = (w + ADAM7_DX[i] - ADAM7_IX[i] - 1) / ADAM7_DX[i];
    passh[i] = (h + ADAM7_DY[i] - ADAM7_IY[i] - 1) / ADAM7_DY[i];
    if(passw[i] == 0) passh[i] = 0;
    if(passh[i] == 0) passw[i] = 0;
  }

  filter_passstart[0] = padded_passstart[0] = passstart[0] = 0;
  for(i = 0; i != 7; ++i)
  {
    /*if passw[i] is 0, it's 0 bytes, not 1 (no filtertype-byte)*/
    filter_passstart[i + 1] = filter_passstart[i]
                            + ((passw[i] && passh[i]) ? passh[i] * (1 + (passw[i] * bpp + 7) / 8) : 0);
    /*bits padded if needed to fill full byte at end of each scanline*/
    padded_passstart[i + 1] = padded_passstart[i] + passh[i] * ((passw[i] * bpp + 7) / 8);
    /*only padded at end of reduced image*/
    passstart[i + 1] = passstart[i] + (passh[i] * passw[i] * bpp + 7) / 8;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x38(%rsp), %ebx
leaq 0x2b41(%rip), %r15      # 0x11fb0
leaq 0x2b5a(%rip), %r12      # 0x11fd0
leaq 0x2b73(%rip), %r13      # 0x11ff0
leaq 0x2b8c(%rip), %rbp      # 0x12010
movq %rdx, %r10
xorl %r14d, %r14d
movl (%r14,%r12), %eax
movl (%r14,%r15), %r11d
notl %eax
addl %r11d, %eax
addl %r9d, %eax
xorl %edx, %edx
divl %r11d
movl %eax, (%rdi,%r14)
movl (%r14,%rbp), %eax
movl (%r14,%r13), %r11d
notl %eax
addl %r11d, %eax
addl %ebx, %eax
xorl %edx, %edx
divl %r11d
movl %eax, (%rsi,%r14)
movl (%rdi,%r14), %edx
testl %edx, %edx
cmovel %edx, %eax
movl %eax, (%rsi,%r14)
testl %eax, %eax
jne 0xf4d4
movl $0x0, (%rdi,%r14)
addq $0x4, %r14
cmpq $0x1c, %r14
jne 0xf48a
movl 0x40(%rsp), %ebp
xorl %eax, %eax
movq %rax, (%r8)
movq %rax, (%rcx)
movq %rax, (%r10)
movl (%rdi,%rax), %edx
movl (%rsi,%rax), %r9d
testl %edx, %edx
je 0xf513
testl %r9d, %r9d
je 0xf510
movl %edx, %ebx
imull %ebp, %ebx
addl $0x7, %ebx
shrl $0x3, %ebx
incl %ebx
imull %r9d, %ebx
jmp 0xf515
xorl %r9d, %r9d
xorl %ebx, %ebx
addq (%r10,%rax,2), %rbx
imull %ebp, %edx
leal 0x7(%rdx), %r11d
imull %r9d, %edx
shrl $0x3, %r11d
movq %rbx, 0x8(%r10,%rax,2)
imull %r9d, %r11d
addq (%rcx,%rax,2), %r11
addl $0x7, %edx
shrl $0x3, %edx
movq %r11, 0x8(%rcx,%rax,2)
addq (%r8,%rax,2), %rdx
movq %rdx, 0x8(%r8,%rax,2)
addq $0x4, %rax
cmpq $0x1c, %rax
jne 0xf4ed
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/phillip-h[P]fractal-gen/lodepng.cpp
// Function: addPaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int)
static void addPaddingBits(unsigned char* out, const unsigned char* in,
                           size_t olinebits, size_t ilinebits, unsigned h)
{
  /*The opposite of the removePaddingBits function
  olinebits must be >= ilinebits*/
  unsigned y;
  size_t diff = olinebits - ilinebits;
  size_t obp = 0, ibp = 0; /*bit pointers*/
  for(y = 0; y != h; ++y)
  {
    size_t x;
    for(x = 0; x < ilinebits; ++x)
    {
      unsigned char bit = readBitFromReversedStream(&ibp, in);
      setBitOfReversedStream(&obp, out, bit);
    }
    /*obp += diff; --> no, fill in some value in the padding bits too, to avoid
    "Use of uninitialised value of size ###" warning from valgrind*/
    for(x = 0; x != diff; ++x) setBitOfReversedStream(&obp, out, 0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
testl %r8d, %r8d
je 0xf62b
movq -0x8(%rsp), %rdx
movq %rcx, %rax
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %r14d, %r14d
subq %rcx, %rdx
testq %rax, %rax
je 0xf5f2
leaq (%r14,%rax), %rbx
movq %rax, %r15
movq %r11, %r12
movq %r12, %rcx
shrq $0x3, %rcx
movl %r12d, %ebp
movzbl (%rsi,%rcx), %r13d
movl %r14d, %ecx
notb %bpl
movzbl %bpl, %r9d
notb %cl
movb $0x1, %bpl
andb $0x7, %cl
andl $0x7, %r9d
shlb %cl, %bpl
btl %r9d, %r13d
jae 0xf5d4
movq %r14, %rcx
shrq $0x3, %rcx
orb %bpl, (%rdi,%rcx)
jmp 0xf5e2
movq %r14, %rcx
notb %bpl
shrq $0x3, %rcx
andb %bpl, (%rdi,%rcx)
incq %r14
incq %r12
decq %r15
jne 0xf599
addq %rax, %r11
jmp 0xf5f5
movq %r14, %rbx
movq %rdx, %r14
cmpq %rax, -0x8(%rsp)
je 0xf61c
movl %ebx, %ecx
movb $-0x2, %r9b
notb %cl
rolb %cl, %r9b
movq %rbx, %rcx
shrq $0x3, %rcx
incq %rbx
andb %r9b, (%rdi,%rcx)
decq %r14
jne 0xf5ff
incl %r10d
movq %rbx, %r14
cmpl %r8d, %r10d
jne 0xf58a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]mphf/./generator.hh
// Function: MPHF::Generator::~Generator()
~Generator() {
      delete [] h;
      delete [] graph;
      BitVector::free(rank_bv);
      BitVector::free(hash_assign_bv);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2f68
callq 0x21c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2f76
callq 0x21c0
movq 0x18(%rbx), %rdi
callq 0x3b50
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x3b50
nop
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]mphf/./generator.hh
// Function: MPHF::Generator::count_line(char const*) const
unsigned count_line(const char* filepath) const {
      unsigned count=0;
      std::ifstream in(filepath);
      if(!in)
	return 0;
      
      std::string line;
      while(std::getline(in, line))
	count++;
      
      return count;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rax
xorl %ebx, %ebx
testb $0x5, 0x40(%rsp,%rax)
jne 0x302d
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorl %ebx, %ebx
leaq 0x20(%rsp), %r14
movq %rsp, %r15
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2260
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3017
incl %ebx
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
jmp 0x2fdc
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x302d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x20(%rsp), %rdi
callq 0x2050
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3061
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x20(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]mphf/./generator.hh
// Function: MPHF::Generator::generate_graph()
void generate_graph() {
      const unsigned middle = hash_value_limit/2;
      std::ifstream in(keyset_filepath);
      std::string key;
      for(unsigned i=0; std::getline(in,key); i++) {
	graph[i][0] = h[0].hash(key.c_str()) % middle;
	graph[i][1] = h[1].hash(key.c_str()) % middle + middle;
      }
      
      // sentinel value
      graph[key_count][0] = hash_value_limit+1;
      graph[key_count][1] = hash_value_limit+1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movl 0x2c(%rdi), %eax
shrl %eax
movl %eax, 0x4(%rsp)
movq %rdi, 0x8(%rsp)
movq (%rdi), %rsi
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2250
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebp, %ebp
movl 0x4(%rsp), %r15d
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x2260
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x31e7
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %r12
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x20b0
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x33a0
xorl %edx, %edx
divl %r15d
movq 0x10(%rbx), %rax
movl %ebp, %r14d
movl %edx, (%rax,%r14,8)
movq 0x8(%rbx), %r12
addq $0x8, %r12
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x20b0
movq %r12, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x33a0
xorl %edx, %edx
divl %r15d
addl %r15d, %edx
movq 0x10(%rbx), %rax
movl %edx, 0x4(%rax,%r14,8)
leaq 0x30(%rsp), %rbx
incl %ebp
jmp 0x3141
movq 0x8(%rsp), %rsi
movl 0x2c(%rsi), %eax
incl %eax
movq 0x10(%rsi), %rcx
movl 0x28(%rsi), %edx
movl %eax, (%rcx,%rdx,8)
movl 0x28(%rsi), %eax
movl 0x2c(%rsi), %edx
incl %edx
movl %edx, 0x4(%rcx,%rax,8)
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x3223
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rdi
callq 0x2050
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x325e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x30(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]mphf/./generator.hh
// Function: MPHF::Generator::check_and_sort_graph()
bool check_and_sort_graph() {
      unsigned beg=0;
      unsigned prev=0;
      unsigned side=0;
      for(; beg < key_count; side=(side+1)%2) {
	VertexLessThan vtl(side);
	std::sort(graph+beg, graph+key_count, vtl);
	
	for(unsigned i=beg; i < key_count; i++)
	  if(graph[i][side] != graph[i+1][side])
	    std::swap(graph[beg++], graph[i]);   // leaf vertex
	  else
	    for(i++; graph[i][side] == graph[i+1][side]; i++);
	
	if(prev==beg)
	  return false;
	prev=beg;
      }
      std::reverse(graph, graph+key_count);
      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x28(%rdi), %eax
movb $0x1, %bl
testl %eax, %eax
je 0x338e
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r13d, %r13d
movl %eax, %eax
movl %r13d, %ecx
movq 0x10(%r14), %rdx
leaq (%rdx,%rax,8), %r15
shlq $0x3, %rax
leaq (,%rcx,8), %rsi
subq %rsi, %rax
leaq (%rdx,%rcx,8), %r12
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %ecx
callq 0x33f5
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x350c
movl 0x28(%r14), %eax
cmpl %eax, %r13d
jae 0x332e
movl %ebp, %edx
movl %r13d, %esi
movl %r13d, %ecx
movq 0x10(%r14), %rdi
movl %esi, %r8d
leaq (%rdi,%r8,8), %r9
movl (%r9,%rdx,4), %r8d
incl %esi
cmpl 0x8(%r9,%rdx,4), %r8d
jne 0x3312
leaq (%rdi,%rdx,4), %rdi
incl %esi
cmpl (%rdi,%rsi,8), %r8d
je 0x3308
jmp 0x3328
movl %ecx, %eax
incl %ecx
movq (%rdi,%rax,8), %r8
movq (%r9), %r10
movq %r10, (%rdi,%rax,8)
movq %r8, (%r9)
movl 0x28(%r14), %eax
cmpl %eax, %esi
jb 0x32ec
jmp 0x3331
movl %r13d, %ecx
cmpl %ecx, %r13d
je 0x338c
notl %ebp
andl $0x1, %ebp
movl %ecx, %r13d
cmpl %eax, %ecx
jb 0x3290
movq 0x10(%r14), %rcx
movl %eax, %edx
testl %eax, %eax
setne %sil
leaq (%rcx,%rdx,8), %rax
addq $-0x8, %rax
cmpq %rcx, %rax
seta %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x338e
addq $0x8, %rcx
movq -0x8(%rcx), %rdx
movq (%rax), %rsi
movq %rsi, -0x8(%rcx)
movq %rdx, (%rax)
addq $-0x8, %rax
leaq 0x8(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jb 0x336c
jmp 0x338e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]mphf/./hash_impl.hh
// Function: MPHF::HashImpl::hash(char const*, unsigned int) const
unsigned hash(const char* key, unsigned size) const {
      const unsigned* u = (const unsigned*)(key);
      unsigned h = param.ini;
      unsigned i = sizeof(unsigned);
      for(; i <= size; i += sizeof(unsigned), u++) 
	h = h*param.mul ^ *u + (h>>ui_size_minus8);
      
      if((i-=sizeof(unsigned)) != size)
	for(; i < size; i++)
	  h = h*param.mul ^ key[i] + (h>>ui_size_minus8);
      
      return h;
    }

// Assembly:
movl (%rdi), %eax
xorl %ecx, %ecx
cmpl $0x4, %edx
jb 0x33cc
movl 0x4(%rdi), %r8d
xorl %ecx, %ecx
movl %r8d, %r9d
imull %eax, %r9d
shrl $0x18, %eax
addl (%rsi,%rcx), %eax
xorl %r9d, %eax
addq $0x4, %rcx
leal 0x4(%rcx), %r9d
cmpl %edx, %r9d
jbe 0x33af
cmpl %edx, %ecx
jae 0x33f4
movl 0x4(%rdi), %edi
movl %ecx, %ecx
movl %edx, %edx
movl %edi, %r8d
imull %eax, %r8d
movsbl (%rsi,%rcx), %r9d
shrl $0x18, %eax
addl %r9d, %eax
xorl %r8d, %eax
incq %rcx
cmpq %rcx, %rdx
jne 0x33d7
retq
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]mphf/./bit_vector.hh
// Function: MPHF::BitVector::build_rank_index()
void build_rank_index() {
      unsigned* ri = const_cast<unsigned*>(rank_index);
      unsigned limit = rank_index_size();
      unsigned acc_1bit_count=0;
      for(unsigned i=0; i < limit; i++) {
	ri[i] = acc_1bit_count;
	if(i != limit-1)
	  for(unsigned j=0; j < BR_TIMES; j++)
	    acc_1bit_count += log_count(blocks[i*BR_TIMES+j]);
      }
    }

// Assembly:
movl $0xff, %eax
addl (%rdi), %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x3b4e
movq 0x10(%rdi), %rcx
shrl $0x8, %eax
leal -0x1(%rax), %edx
movq 0x8(%rdi), %rsi
xorl %edi, %edi
movdqa 0x586(%rip), %xmm0      # 0x4010
movdqa 0x58e(%rip), %xmm1      # 0x4020
movdqa 0x596(%rip), %xmm2      # 0x4030
movdqa 0x59e(%rip), %xmm3      # 0x4040
xorl %r8d, %r8d
movl %r8d, (%rcx,%rdi,4)
cmpq %rdx, %rdi
je 0x3b3e
movd %r8d, %xmm4
xorl %r8d, %r8d
movdqu (%rsi,%r8,4), %xmm5
movdqa %xmm5, %xmm6
psrld $0x1, %xmm6
pand %xmm0, %xmm6
pand %xmm0, %xmm5
paddd %xmm6, %xmm5
movdqa %xmm5, %xmm6
psrld $0x2, %xmm6
pand %xmm1, %xmm6
pand %xmm1, %xmm5
paddd %xmm6, %xmm5
movdqa %xmm5, %xmm6
psrld $0x4, %xmm6
paddd %xmm5, %xmm6
pand %xmm2, %xmm6
movdqa %xmm6, %xmm5
psrld $0x8, %xmm5
paddd %xmm6, %xmm5
movdqa %xmm5, %xmm6
psrld $0x10, %xmm6
paddd %xmm5, %xmm6
pand %xmm3, %xmm6
paddd %xmm6, %xmm4
addq $0x4, %r8
cmpq $0x8, %r8
jne 0x3aba
pshufd $0xee, %xmm4, %xmm5     # xmm5 = xmm4[2,3,2,3]
paddd %xmm4, %xmm5
pshufd $0x55, %xmm5, %xmm4     # xmm4 = xmm5[1,1,1,1]
paddd %xmm5, %xmm4
movd %xmm4, %r8d
incq %rdi
addq $0x20, %rsi
cmpq %rax, %rdi
jne 0x3aa5
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: Graph::get_sources_and_sinks(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&) const
void Graph::get_sources_and_sinks(ivec& sources, ivec& sinks) const {
    for(int u=0; u<n; ++u) {
        if(_preds[u].empty()) {
            sources.push_back(u);
        }
        if(_succs[u].empty()) {
            sinks.push_back(u);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, 0x4(%rsp)
cmpl $0x0, (%rdi)
jle 0x1384
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
leaq 0x4(%rsp), %r12
movslq %eax, %rcx
movq 0x8(%r15), %rdx
leaq (%rcx,%rcx,2), %rcx
movq (%rdx,%rcx,8), %rsi
cmpq 0x8(%rdx,%rcx,8), %rsi
jne 0x133c
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1331
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x133c
movq %r14, %rdi
movq %r12, %rdx
callq 0x1866
movslq 0x4(%rsp), %rax
movq 0x20(%r15), %rcx
leaq (%rax,%rax,2), %rdx
movq (%rcx,%rdx,8), %rsi
cmpq 0x8(%rcx,%rdx,8), %rsi
jne 0x1375
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x136a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x1375
movq %rbx, %rdi
movq %r12, %rdx
callq 0x1866
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cmpl (%r15), %eax
jl 0x1305
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: Graph::print(_IO_FILE*) const
void Graph::print(FILE* fp) const {
    for(int u=0; u<n; ++u) {
        fprintf(fp, "%d: ", u);
        print_icont(fp, _succs[u], ", ", "[", "] ");
        print_icont(fp, _preds[u], ", ", "[", "]\n");
    }
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x1425
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xc58(%rip), %r12       # 0x2009
leaq 0xc54(%rip), %r13       # 0x200c
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rbx, %rdi
leaq 0xc3d(%rip), %rsi       # 0x2004
movl %ebp, %edx
xorl %eax, %eax
callq 0x1100
movq 0x20(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
leaq 0xc27(%rip), %r8        # 0x200e
callq 0x1608
movq 0x8(%r14), %rsi
addq %r15, %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r13, %rcx
leaq 0xc0e(%rip), %r8        # 0x2011
callq 0x1608
incq %rbp
movslq (%r14), %rax
addq $0x18, %r15
cmpq %rax, %rbp
jl 0x13bd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: DFSHelper::do_dfs(int)
void DFSHelper::do_dfs(int u) {
    if(visited[u]) {
        return;
    }
    visited[u] = true;
    for(int v: graph.succs(u)) {
        if(!visited[v]) {
            do_dfs(v);
        }
    }
    topolist.push_back(u);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movslq %esi, %rcx
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %esi, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x8(%rdi), %rax
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq 0x3f(%r15), %rsi
andq %rcx, %rsi
xorl %edx, %edx
cmpq %r15, %rsi
setbe %dl
movl $0x1, %esi
shlq %cl, %rsi
movq -0x8(%rax,%rdx,8), %rdi
btq %rcx, %rdi
jb 0x1516
leaq -0x8(,%rdx,8), %rdx
orq %rsi, %rdi
movq %rdi, (%rax,%rdx)
movq (%r14), %rax
movq 0x20(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %r12
movq 0x8(%rax,%rcx,8), %r13
cmpq %r13, %r12
je 0x14f2
leaq 0x3f(%r15), %rbp
movslq (%r12), %rsi
leal 0x3f(%rsi), %eax
testq %rsi, %rsi
cmovnsl %esi, %eax
sarl $0x6, %eax
cltq
shlq $0x3, %rax
addq 0x8(%r14), %rax
movq %rsi, %rcx
andq %rbp, %rcx
xorl %edx, %edx
cmpq %r15, %rcx
setbe %dl
movq -0x8(%rax,%rdx,8), %rax
btq %rsi, %rax
jb 0x14e9
movq %r14, %rdi
callq 0x1426
addq $0x4, %r12
cmpq %r13, %r12
jne 0x14ae
movq 0x30(%r14), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x150c
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x1516
leaq 0x4(%rsp), %rdx
callq 0x1866
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sharmaeklavya2[P]ddos-on-anycast/src/lib/dag.cpp
// Function: rtoposort(Graph const&, std::vector<int, std::allocator<int>>&)
void rtoposort(const Graph& graph, ivec& output) {
    int n = graph.order();
    output.reserve(n);
    DFSHelper dfs_helper(graph, output);
    for(int u=0; u<n; ++u) {
        dfs_helper.do_dfs(u);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %r15
movslq (%rdi), %rbx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x169c
leaq 0x10(%rsp), %r12
movq %r15, -0x8(%r12)
movslq (%r15), %rsi
leaq 0x7(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x6(%rsp), %rcx
movq %r12, %rdi
callq 0x172e
movq %r14, 0x28(%r12)
testq %rbx, %rbx
jle 0x1588
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x1426
incl %ebp
cmpl %ebp, %ebx
jne 0x1578
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1597
callq 0x10b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x15b6
callq 0x10b0
movq %rbx, %rdi
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O3/sharmaeklavya2[P]ddos-on-anycast/src/lib/util.hpp
// Function: void print_icont<std::vector<int, std::allocator<int>>>(_IO_FILE*, std::vector<int, std::allocator<int>> const&, char const*, char const*, char const*)
void print_icont(FILE* fp, const C& c, const char* sep, const char* begs, const char* ends) {
    fprintf(fp, "%s", begs);
    int n = c.size();
    if(n > 0) {
        typename C::const_iterator it = c.begin();
        fprintf(fp, "%d", *(it++));
        while(it != c.end()) {
            fprintf(fp, "%s%d", sep, *(it++));
        }
    }
    fprintf(fp, "%s", ends);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rdi
movq %r14, %rsi
callq 0x10d0
movq (%r12), %rbp
movq 0x8(%r12), %rax
subq %rbp, %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x1682
movl (%rbp), %edx
leaq 0xa01(%rip), %rsi       # 0x2049
movq %r14, %rdi
xorl %eax, %eax
callq 0x1100
addq $0x4, %rbp
cmpq 0x8(%r12), %rbp
je 0x1682
leaq 0x9ca(%rip), %r13       # 0x202e
movl (%rbp), %ecx
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1100
addq $0x4, %rbp
cmpq 0x8(%r12), %rbp
jne 0x1664
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/sharmaeklavya2[P]ddos-on-anycast/src/dag.cpp
// Function: main
int main() {
    int n, m;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
    scanf("%d%d", &n, &m);
#pragma GCC diagnostic pop
    Graph graph(n);
    for(int i=0; i<m; ++i) {
        int u, v;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
        scanf("%d%d", &u, &v);
#pragma GCC diagnostic pop
        graph.add_edge(u, v);
    }
    ivec topolist;
    toposort(graph, topolist);
    printf("%d", topolist[0]);
    for(int i=1; i<n; ++i) {
        printf(" %d", topolist[i]);
    }
    printf("\n");
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
leaq 0x694(%rip), %rdi       # 0x2043
leaq 0x4(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x10e0
movl (%rbx), %esi
leaq 0x28(%rsp), %rdi
callq 0x1aee
cmpl $0x0, (%r14)
jle 0x1a18
leaq 0x664(%rip), %rbx       # 0x2043
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10e0
movl 0x10(%rsp), %esi
movl 0x8(%rsp), %edx
movq %r12, %rdi
callq 0x1b44
incl %ebp
cmpl 0xc(%rsp), %ebp
jl 0x19f0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0x15be
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0x606(%rip), %rdi       # 0x2049
xorl %eax, %eax
callq 0x1030
cmpl $0x2, 0x4(%rsp)
jl 0x1a7e
movl $0x1, %r14d
leaq 0x5ea(%rip), %rbx       # 0x2048
movq 0x10(%rsp), %rax
movl (%rax,%r14,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
incq %r14
movslq 0x4(%rsp), %rax
cmpq %rax, %r14
jl 0x1a5e
movl $0xa, %edi
callq 0x10f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a97
callq 0x10b0
leaq 0x48(%rsp), %rdi
callq 0x1c46
leaq 0x30(%rsp), %rdi
callq 0x1c46
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ad1
callq 0x10b0
jmp 0x1ad1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1c46
leaq 0x30(%rsp), %rdi
callq 0x1c46
movq %rbx, %rdi
callq 0x1130
nop
// File: /workspace/github_cpp_makefile_star2_O3/thuydx55[P]C-Number-to-Word/NumberRepresentation/Number.cpp
// Function: Number::divideStringToSmallGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
stack<string> Number::divideStringToSmallGroup(const string &numStr) {
    stack<string> groups;

    for (short i = numStr.length()-1; i >= 0; i -= 3) {
        if (i >= 2)
            groups.push(numStr.substr(i-2, 3));
        else
            groups.push(numStr.substr(0, i+1));
    }

    return groups;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %esi, %esi
callq 0x4ef4
movl 0x8(%r14), %eax
decl %eax
movswl %ax, %r13d
testl %r13d, %r13d
js 0x4437
leaq 0x10(%rsp), %r12
movq %rsp, %r15
cmpl $0x2, %r13d
jb 0x43f8
leal -0x2(%r13), %edx
movl $0x3, %ecx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5306
jmp 0x4414
leal 0x1(%r13), %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2140
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5306
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x442a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
addl $-0x3, %r13d
movswl %r13w, %r13d
testl %r13d, %r13d
jns 0x43d1
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x444a
movq %rax, %r14
jmp 0x446a
jmp 0x4451
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x446a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x472c
movq %r14, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/mmoanis[P]mpegts_demux/MpegTsBitStream.cpp
// Function: MpegTsBitStream::MpegTsBitStream(char const*)
MpegTsBitStream::MpegTsBitStream(const char * filename) : m_file(NULL), m_eof(false), m_bad(true)
{
    assert(filename != NULL);

    m_file = fopen(filename, "rb");
    if (!m_file) {
        cerr << "[ERROR]: can't open file \'" << filename << "\'" << endl;
    } else {
        m_bad = false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, (%rdi)
movw $0x100, 0x8(%rdi)       # imm = 0x100
testq %rsi, %rsi
je 0x26d6
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2b23(%rip), %rsi      # 0x516a
movq %r14, %rdi
callq 0x2170
movq %rax, (%rbx)
testq %rax, %rax
je 0x2663
movb $0x0, 0x9(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x5986(%rip), %rbx      # 0x7ff0
leaq 0x2afc(%rip), %rsi      # 0x516d
movl $0x1a, %edx
movq %rbx, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2160
leaq 0x2b9b(%rip), %rsi      # 0x5236
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2160
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20c0
leaq 0x2a39(%rip), %rdi      # 0x5116
leaq 0x2a43(%rip), %rsi      # 0x5127
leaq 0x2a50(%rip), %rcx      # 0x513b
movl $0x9, %edx
callq 0x20a0
nop