LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/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->lengths = (unsigned*)lodepng_malloc(numcodes * sizeof(unsigned));
  if(!tree->lengths) return 83; /*alloc fail*/
  tree->maxbitlen = maxbitlen;
  tree->numcodes = (unsigned)numcodes; /*number of symbols*/

  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 %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(,%rcx,4), %rcx
movl $0x1, %r12d
xorl %eax, %eax
leaq (%r15,%rax), %rsi
leaq -0x4(%rcx), %rdi
decq %r12
cmpq %rdx, %rsi
jbe 0xeb85
decq %rax
cmpl $0x0, -0x8(%r14,%rcx)
movq %rdi, %rcx
je 0xeb67
callq 0x22b0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xebc2
leaq (%r15,%r12), %rdx
movl %ebp, 0x10(%rbx)
addl %r12d, %r15d
movl %r15d, 0x14(%rbx)
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %ecx
callq 0x2711
testl %eax, %eax
jne 0xebc7
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xddc5
movl $0x53, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_init(unsigned char**, ucvector*, unsigned long, char const*)
static unsigned lodepng_chunk_init(unsigned char** chunk,
                                   ucvector* out,
                                   size_t length, const char* type) {
  size_t new_length = out->size;
  if(lodepng_addofl(new_length, length, &new_length)) return 77;
  if(lodepng_addofl(new_length, 12, &new_length)) return 77;
  if(!ucvector_resize(out, new_length)) return 83; /*alloc fail*/
  *chunk = out->data + new_length - length - 12u;

  /*1: length*/
  lodepng_set32bitInt(*chunk, (unsigned)length);

  /*2: chunk name (4 letters)*/
  lodepng_memcpy(*chunk + 4, type, 4);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rsi), %rbp
movl $0x4d, %eax
addq %rdx, %rbp
jb 0xec41
subq $-0xc, %rbp
jae 0xec41
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %rbp, 0x8(%rsi)
movq %rsi, %rdi
movq %rbp, %rsi
callq 0xdb6a
testl %eax, %eax
je 0xec3c
addq (%r12), %rbp
subq %rbx, %rbp
leaq -0xc(%rbp), %rax
movq %rax, (%r15)
movl %ebx, %eax
shrl $0x18, %eax
movb %al, -0xc(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, -0xb(%rbp)
movb %bh, -0xa(%rbp)
movb %bl, -0x9(%rbp)
movq (%r15), %rax
movl (%r14), %ecx
movl %ecx, 0x4(%rax)
xorl %eax, %eax
jmp 0xec41
movl $0x53, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::getPNGHeaderInfo(std::vector<unsigned char, std::allocator<unsigned char>> const&)
LodePNGInfo getPNGHeaderInfo(const std::vector<unsigned char>& png) {
  unsigned w, h;
  lodepng::State state;
  lodepng_inspect(&w, &h, &state, png.empty() ? NULL : &png[0], png.size());
  return state.info_png;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x290, %rsp            # imm = 0x290
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xd3c8
movq (%r14), %rax
movq 0x8(%r14), %r8
xorl %ecx, %ecx
subq %rax, %r8
cmovneq %rax, %rcx
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x8215
leaq 0xe0(%rsp), %rsi
movl $0x1a8, %edx            # imm = 0x1A8
movq %rbx, %rdi
callq 0x21e0
leaq 0x10(%rsp), %rdi
callq 0xd3f0
movq %rbx, %rax
addq $0x290, %rsp            # imm = 0x290
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd3f0
movq %rbx, %rdi
callq 0x23c0
movq %rax, %rdi
callq 0x14d36
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::getChunkInfo(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
unsigned getChunkInfo(std::vector<std::string>& names, std::vector<size_t>& sizes,
                      const std::vector<unsigned char>& png) {
  // Listing chunks is based on the original file, not the decoded png info.
  const unsigned char *chunk, *end;
  end = &png.back() + 1;
  chunk = &png.front() + 8;

  while(chunk < end && end - chunk >= 8) {
    char type[5];
    lodepng_chunk_type(type, chunk);
    if(std::string(type).size() != 4) return 1;

    unsigned length = lodepng_chunk_length(chunk);
    names.push_back(type);
    sizes.push_back(length);
    chunk = lodepng_chunk_next_const(chunk, end);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq (%rdx), %r13
movq 0x8(%rdx), %rax
addq $0x8, %r13
movq %rax, 0x28(%rsp)
subq %r13, %rax
setbe %cl
cmpq $0x8, %rax
setl %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x10d52
movq %rsi, %r14
leaq 0x18(%rsp), %r12
leaq 0x3(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x544e
movq %r12, 0x8(%rsp)
movq %rbp, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x3, %rdx
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x14f6e
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %r15
cmpq %r12, %rdi
je 0x10ca5
callq 0x2210
cmpq $0x4, %r15
jne 0x10d4d
movq %r13, %rdi
callq 0x5449
movl %eax, %r15d
movq %r12, 0x8(%rsp)
movq %rbp, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x3, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x14f6e
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x14d42
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x10cfb
callq 0x2210
movl %r15d, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x10d1a
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x10d27
movq %r14, %rdi
leaq 0x8(%rsp), %rdx
callq 0x15324
movq %r13, %rdi
movq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x55b2
subq %rax, %r15
jbe 0x10d49
movq %rax, %r13
cmpq $0x7, %r15
jg 0x10c64
xorl %eax, %eax
jmp 0x10d52
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x10d73
callq 0x2210
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::getPaletteValue(unsigned char const*, unsigned long, int)
int getPaletteValue(const unsigned char* data, size_t i, int bits) {
  if(bits == 8) return data[i];
  else if(bits == 4) return (data[i / 2] >> ((i % 2) * 4)) & 15;
  else if(bits == 2) return (data[i / 4] >> ((i % 4) * 2)) & 3;
  else if(bits == 1) return (data[i / 8] >> (i % 8)) & 1;
  else return 0;
}

// Assembly:
xorl %eax, %eax
decl %edx
cmpl $0x7, %edx
ja 0x11910
leaq 0x6453f(%rip), %rcx     # 0x75e30
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %rsi, %rax
shrq $0x3, %rax
movzbl (%rdi,%rax), %ecx
andl $0x7, %esi
xorl %eax, %eax
btl %esi, %ecx
setb %al
retq
movq %rsi, %rax
shrq %rax
movzbl (%rdi,%rax), %eax
shll $0x2, %esi
andb $0x4, %sil
movl %esi, %ecx
shrl %cl, %eax
andl $0xf, %eax
retq
movq %rsi, %rax
shrq $0x2, %rax
movzbl (%rdi,%rax), %eax
addl %esi, %esi
andb $0x6, %sil
movl %esi, %ecx
shrl %cl, %eax
andl $0x3, %eax
retq
movzbl (%rdi,%rsi), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::convertFromXYZFloat(float*, float const*, unsigned int, unsigned int, LodePNGState const*, float const*, unsigned int)
unsigned convertFromXYZFloat(float* out, const float* in, unsigned w, unsigned h,
                             const LodePNGState* state,
                             const float whitepoint[3], unsigned rendering_intent) {
  unsigned error = 0;
  const LodePNGInfo* info = &state->info_png;

  /* parse ICC if present */
  unsigned use_icc = 0;
  LodePNGICC icc;
  lodepng_icc_init(&icc);
  if(info->iccp_defined) {
    error = parseICC(&icc, info->iccp_profile, info->iccp_profile_size);
    if(error) goto cleanup; /* corrupted ICC profile */
    use_icc = validateICC(&icc);
  }

  /* Handle gamut */
  error = convertFromXYZ_chrm(out, in, w, h, info, use_icc, &icc, whitepoint, rendering_intent);
  if(error) goto cleanup;

  /* Handle transfer function */
  error = convertFromXYZ_gamma(out, w, h, info, use_icc, &icc);
  if(error) goto cleanup;

cleanup:
  lodepng_icc_cleanup(&icc);
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r9, %r11
movq %r8, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rsp)
movups %xmm0, 0xd0(%rsp)
movups %xmm0, 0x108(%rsp)
xorl %r12d, %r12d
cmpl $0x0, 0x1cc(%r8)
je 0x13646
movq %rsi, (%rsp)
movq %r11, 0x8(%rsp)
movq %rdi, %r13
movl %edx, %r15d
movl %ecx, %r14d
movq 0x1d8(%rbx), %rsi
movl 0x1e0(%rbx), %edx
leaq 0x10(%rsp), %rdi
callq 0x11e1d
movl $0x1, %ebp
testl %eax, %eax
jne 0x1369b
movl 0x10(%rsp), %eax
testl %eax, %eax
je 0x13631
cmpl $0x2, %eax
movl %r14d, %ecx
movl %r15d, %edx
movq %r13, %rdi
movq 0x8(%rsp), %r11
movq (%rsp), %rsi
jne 0x13619
cmpl $0x0, 0x64(%rsp)
je 0x13646
cmpl $0x0, 0x54(%rsp)
je 0x13646
xorl %r12d, %r12d
cmpl $0x0, 0x8c(%rsp)
setne %r12b
jmp 0x13646
movl %eax, %r12d
movl %r14d, %ecx
movl %r15d, %edx
movq %r13, %rdi
movq 0x8(%rsp), %r11
movq (%rsp), %rsi
movl 0x170(%rsp), %eax
addq $0xd0, %rbx
subq $0x8, %rsp
leaq 0x18(%rsp), %r10
movq %rdi, %r15
movl %edx, %r14d
movl %ecx, %r13d
movq %rbx, %r8
movl %r12d, %r9d
pushq %rax
pushq %r11
pushq %r10
callq 0x13039
addq $0x20, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x1369b
leaq 0x10(%rsp), %r9
movq %r15, %rdi
movl %r14d, %esi
movl %r13d, %edx
movq %rbx, %rcx
movl %r12d, %r8d
callq 0x13261
movl %eax, %ebp
movq 0x98(%rsp), %rdi
callq 0x22a0
movq 0xd0(%rsp), %rdi
callq 0x22a0
movq 0x108(%rsp), %rdi
callq 0x22a0
movl %ebp, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::convertToSrgb(unsigned char*, unsigned char const*, unsigned int, unsigned int, LodePNGState const*)
unsigned convertToSrgb(unsigned char* out, const unsigned char* in,
                       unsigned w, unsigned h,
                       const LodePNGState* state_in) {
  LodePNGState srgb;
  lodepng_state_init(&srgb);
  lodepng_color_mode_copy(&srgb.info_raw, &state_in->info_raw);
  return convertRGBModel(out, in, w, h, &srgb, state_in, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xa6b0
movl $0xa8, %esi
leaq (%rsi,%r13), %rdi
addq %rbx, %rsi
callq 0x58b6
movl $0x1, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r13, %r8
movq %rbx, %r9
callq 0x136d6
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::convertFromSrgb(unsigned char*, unsigned char const*, unsigned int, unsigned int, LodePNGState const*)
unsigned convertFromSrgb(unsigned char* out, const unsigned char* in,
                         unsigned w, unsigned h,
                         const LodePNGState* state_out) {
  LodePNGState srgb;
  lodepng_state_init(&srgb);
  lodepng_color_mode_copy(&srgb.info_raw, &state_out->info_raw);
  return convertRGBModel(out, in, w, h, state_out, &srgb, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xa6b0
movl $0xa8, %esi
leaq (%rsi,%r13), %rdi
addq %rbx, %rsi
callq 0x58b6
movl $0x1, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq %r13, %r9
callq 0x136d6
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::isICCword(unsigned char const*, unsigned long, unsigned long, char const*)
static unsigned isICCword(const unsigned char* data, size_t size, size_t pos, const char* word) {
  if(pos + 4 > size) return 0;
  return data[pos + 0] == (unsigned char)word[0] &&
         data[pos + 1] == (unsigned char)word[1] &&
         data[pos + 2] == (unsigned char)word[2] &&
         data[pos + 3] == (unsigned char)word[3];
}

// Assembly:
leaq 0x4(%rdx), %r8
xorl %eax, %eax
cmpq %rsi, %r8
ja 0x13a48
movb (%rdi,%rdx), %sil
cmpb (%rcx), %sil
jne 0x13a48
movb 0x1(%rdi,%rdx), %sil
cmpb 0x1(%rcx), %sil
jne 0x13a48
movb 0x2(%rdi,%rdx), %sil
cmpb 0x2(%rcx), %sil
jne 0x13a48
movb 0x3(%rdi,%rdx), %dl
xorl %eax, %eax
cmpb 0x3(%rcx), %dl
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::getAdaptationMatrix(float*, int, float, float, float, float, float, float)
static unsigned getAdaptationMatrix(float* m, int type,
                                    float wx0, float wy0, float wz0,
                                    float wx1, float wy1, float wz1) {
  int i;
  static const float bradford[9] = {
    0.8951f, 0.2664f, -0.1614f,
    -0.7502f, 1.7135f, 0.0367f,
    0.0389f, -0.0685f, 1.0296f
  };
  static const float bradfordinv[9] = {
    0.9869929f, -0.1470543f, 0.1599627f,
    0.4323053f, 0.5183603f, 0.0492912f,
   -0.0085287f, 0.0400428f, 0.9684867f
  };
  static const float vonkries[9] = {
    0.40024f, 0.70760f, -0.08081f,
    -0.22630f, 1.16532f, 0.04570f,
    0.00000f, 0.00000f, 0.91822f,
  };
  static const float vonkriesinv[9] = {
    1.8599364f, -1.1293816f, 0.2198974f,
    0.3611914f, 0.6388125f, -0.0000064f,
   0.0000000f, 0.0000000f, 1.0890636f
  };
  if(type == 0) {
    for(i = 0; i < 9; i++) m[i] = 0;
    m[0] = wx1 / wx0;
    m[4] = wy1 / wy0;
    m[8] = wz1 / wz0;
  } else {
    const float* cat = (type == 1) ? bradford : vonkries;
    const float* inv = (type == 1) ? bradfordinv : vonkriesinv;
    float rho0, gam0, bet0, rho1, gam1, bet1, rho2, gam2, bet2;
    mulMatrix(&rho0, &gam0, &bet0, cat, wx0, wy0, wz0);
    mulMatrix(&rho1, &gam1, &bet1, cat, wx1, wy1, wz1);
    rho2 = rho1 / rho0;
    gam2 = gam1 / gam0;
    bet2 = bet1 / bet0;
    /* Multiply diagonal matrix with cat */
    for(i = 0; i < 3; i++) {
      m[i + 0] = rho2 * cat[i + 0];
      m[i + 3] = gam2 * cat[i + 3];
      m[i + 6] = bet2 * cat[i + 6];
    }
    mulMatrixMatrix(m, inv, m);
  }
  return 0; /* ok */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm5, 0xc(%rsp)
movss %xmm4, 0x8(%rsp)
movss %xmm3, 0x4(%rsp)
movq %rdi, %rbx
cvtss2sd %xmm0, %xmm0
cvtss2sd %xmm1, %xmm1
cvtss2sd %xmm2, %xmm2
leaq 0x61621(%rip), %r14     # 0x75f40
leaq 0x24(%rsp), %r13
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x1466c
xorps %xmm0, %xmm0
cvtss2sd 0x4(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x8(%rsp), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0xc(%rsp), %xmm2
leaq 0x20(%rsp), %rbp
leaq 0x1c(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x1466c
movss (%rbp), %xmm0
divss (%r13), %xmm0
movss (%r15), %xmm1
leaq 0x14(%rsp), %rax
divss (%rax), %xmm1
movss (%r12), %xmm2
leaq 0x10(%rsp), %rax
divss (%rax), %xmm2
xorl %eax, %eax
movss (%r14,%rax,4), %xmm3
mulss %xmm0, %xmm3
movss %xmm3, (%rbx,%rax,4)
movss 0xc(%r14,%rax,4), %xmm3
mulss %xmm1, %xmm3
movss %xmm3, 0xc(%rbx,%rax,4)
movss 0x18(%r14,%rax,4), %xmm3
mulss %xmm2, %xmm3
movss %xmm3, 0x18(%rbx,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x1499e
leaq 0x61591(%rip), %rsi     # 0x75f70
movq %rbx, %rdi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14bd7
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::mulMatrixMatrix(float*, float const*, float const*)
static void mulMatrixMatrix(float* result, const float* a, const float* b) {
  int i;
  float temp[9]; /* temp is to allow result and a or b to be the same */
  mulMatrix(&temp[0], &temp[3], &temp[6], a, b[0], b[3], b[6]);
  mulMatrix(&temp[1], &temp[4], &temp[7], a, b[1], b[4], b[7]);
  mulMatrix(&temp[2], &temp[5], &temp[8], a, b[2], b[5], b[8]);
  for(i = 0; i < 9; i++) result[i] = temp[i];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x18(%rsp), %rdx
cvtss2sd (%r15), %xmm0
cvtss2sd 0xc(%r15), %xmm1
cvtss2sd 0x18(%r15), %xmm2
movq %rsp, %rdi
movq %r14, %rcx
callq 0x1466c
leaq 0x4(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
xorps %xmm0, %xmm0
cvtss2sd 0x4(%r15), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x10(%r15), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x1c(%r15), %xmm2
movq %r14, %rcx
callq 0x1466c
leaq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x20(%rsp), %r12
xorps %xmm0, %xmm0
cvtss2sd 0x8(%r15), %xmm0
xorps %xmm1, %xmm1
cvtss2sd 0x14(%r15), %xmm1
xorps %xmm2, %xmm2
cvtss2sd 0x20(%r15), %xmm2
movq %r12, %rdx
movq %r14, %rcx
callq 0x1466c
movl (%r12), %eax
movl %eax, 0x20(%rbx)
movaps -0x20(%r12), %xmm0
movaps -0x10(%r12), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::isSRGB(LodePNGInfo const*)
static unsigned isSRGB(const LodePNGInfo* info) {
  if(!info) return 1; /* the default is considered sRGB. */

  /* TODO: support some ICC profiles that represent sRGB too. Tricky due to
  possible slight deviations and many ways of representing its gamma function. */
  if(info->iccp_defined) return 0;

  if(info->srgb_defined) return 1;

  /* The gamma chunk is unable to represent sRGB's two-part gamma, so cannot
  be sRGB, even if it's the default 45455. */
  if(info->gama_defined) return 0;

  if(info->chrm_defined) {
    if(info->chrm_white_x != 31270 || info->chrm_white_y != 32900) return 0;
    if(info->chrm_red_x != 64000 || info->chrm_red_y != 33000) return 0;
    if(info->chrm_green_x != 30000 || info->chrm_green_y != 60000) return 0;
    if(info->chrm_blue_x != 15000 || info->chrm_blue_y != 6000) return 0;
  }

  return 1;
}

// Assembly:
testq %rdi, %rdi
je 0x14cb8
xorl %eax, %eax
cmpl $0x0, 0xfc(%rdi)
je 0x14caf
retq
cmpl $0x0, 0xf4(%rdi)
je 0x14cbe
movl $0x1, %eax
retq
cmpl $0x0, 0xc8(%rdi)
jne 0x14cae
cmpl $0x0, 0xd0(%rdi)
je 0x14cb8
cmpl $0x7a26, 0xd4(%rdi)     # imm = 0x7A26
jne 0x14cae
cmpl $0x8084, 0xd8(%rdi)     # imm = 0x8084
jne 0x14cae
cmpl $0xfa00, 0xdc(%rdi)     # imm = 0xFA00
jne 0x14cae
cmpl $0x80e8, 0xe0(%rdi)     # imm = 0x80E8
jne 0x14cae
cmpl $0x7530, 0xe4(%rdi)     # imm = 0x7530
jne 0x14cae
cmpl $0xea60, 0xe8(%rdi)     # imm = 0xEA60
jne 0x14cae
cmpl $0x3a98, 0xec(%rdi)     # imm = 0x3A98
jne 0x14cae
cmpl $0x1770, 0xf0(%rdi)     # imm = 0x1770
jne 0x14cae
jmp 0x14cb8
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: fromBase64(int)
int fromBase64(int v) {
  if(v >= 'A' && v <= 'Z') return (v - 'A');
  if(v >= 'a' && v <= 'z') return (v - 'a' + 26);
  if(v >= '0' && v <= '9') return (v - '0' + 52);
  if(v == '+') return 62;
  if(v == '/') return 63;
  return 0; //v == '='
}

// Assembly:
leal -0x41(%rdi), %eax
cmpl $0x1a, %eax
jae 0x1650d
retq
leal -0x61(%rdi), %eax
cmpl $0x19, %eax
ja 0x1651a
addl $-0x47, %edi
jmp 0x16525
leal -0x30(%rdi), %eax
cmpl $0x9, %eax
ja 0x16528
addl $0x4, %edi
movl %edi, %eax
retq
xorl %eax, %eax
cmpl $0x2f, %edi
movl $0x3f, %ecx
cmovnel %eax, %ecx
cmpl $0x2b, %edi
movl $0x3e, %eax
cmovnel %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: getRandom()
unsigned getRandom() {
  static unsigned s = 1000000000;
  // xorshift32, good enough for testing
  s ^= (s << 13);
  s ^= (s >> 17);
  s ^= (s << 5);
  return s;
}

// Assembly:
movl 0x9dcd9(%rip), %eax     # 0xb4220
movl %eax, %ecx
shll $0xd, %ecx
xorl %eax, %ecx
movl %ecx, %edx
shrl $0x11, %edx
xorl %ecx, %edx
movl %edx, %eax
shll $0x5, %eax
xorl %edx, %eax
movl %eax, 0x9dcbe(%rip)     # 0xb4220
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: md5sum[abi:cxx11](unsigned char const*, unsigned long)
std::string md5sum(const unsigned char* data, size_t size) {
  unsigned a0, b0, c0, d0;
  md5sum(data, size, &a0, &b0, &c0, &d0);
  char result[33];
  //sprintf(result, "%8.8x%8.8x%8.8x%8.8x", a0, b0, c0, d0);
  sprintf(result, "%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x",
          a0 & 255, (a0 >> 8) & 255, (a0 >> 16) & 255, (a0 >> 24) & 255,
          b0 & 255, (b0 >> 8) & 255, (b0 >> 16) & 255, (b0 >> 24) & 255,
          c0 & 255, (c0 >> 8) & 255, (c0 >> 16) & 255, (c0 >> 24) & 255,
          d0 & 255, (d0 >> 8) & 255, (d0 >> 16) & 255, (d0 >> 24) & 255);
  return std::string(result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, 0x28(%rsp)
leaq 0x3c(%rsp), %r12
leaq 0x38(%rsp), %r13
leaq 0x34(%rsp), %r15
leaq 0x4(%rsp), %r9
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x1656a
movl (%r12), %r9d
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
movl (%r13), %r12d
movl %r12d, %esi
andl %eax, %esi
movq %rsi, 0x20(%rsp)
movl %r12d, %esi
shrl $0x8, %esi
andl %eax, %esi
movq %rsi, 0x18(%rsp)
movl %r12d, %esi
shrl $0x10, %esi
andl %eax, %esi
movq %rsi, 0x10(%rsp)
movl (%r15), %ebp
movl %ebp, %esi
andl %eax, %esi
movq %rsi, 0x8(%rsp)
movl %ebp, %r14d
shrl $0x8, %r14d
andl %eax, %r14d
movl %ebp, %ebx
shrl $0x10, %ebx
andl %eax, %ebx
leaq 0x4(%rsp), %rsi
movl (%rsi), %r15d
movl %r15d, %r10d
andl %eax, %r10d
movl %r15d, %r11d
shrl $0x8, %r11d
andl %eax, %r11d
movl %r15d, %r13d
shrl $0x10, %r13d
andl %eax, %r13d
shrl $0x18, %r9d
shrl $0x18, %r12d
shrl $0x18, %ebp
shrl $0x18, %r15d
leaq 0x5fa91(%rip), %rsi     # 0x76324
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
pushq %r15
pushq %r13
pushq %r11
pushq %r10
pushq %rbp
pushq %rbx
pushq %r14
pushq 0x40(%rsp)
pushq %r12
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
callq 0x2070
addq $0x60, %rsp
movq 0x28(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14f6e
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: assertPixels(Image&, unsigned char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertPixels(Image& image, const unsigned char* decoded, const std::string& message) {
  for(size_t i = 0; i < image.data.size(); i++) {
    int byte_expected = image.data[i];
    int byte_actual = decoded[i];

    //last byte is special due to possible random padding bits which need not to be equal
    if(i == image.data.size() - 1) {
      size_t numbits = getNumColorChannels(image.colorType) * image.bitDepth * image.width * image.height;
      size_t padding = 8u - (numbits - 8u * (numbits / 8u));
      if(padding != 8u) {
        //set all padding bits of both to 0
        for(size_t j = 0; j < padding; j++) {
          byte_expected = (byte_expected & (~(1 << j))) % 256;
          byte_actual = (byte_actual & (~(1 << j))) % 256;
        }
      }
    }

    assertEquals(byte_expected, byte_actual, message + " " + valtostr(i));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rbx
movq $0x0, 0x10(%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
je 0x17004
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
leaq 0x18(%rsp), %r12
leaq 0x38(%rsp), %rbp
leaq 0x58(%rsp), %r13
movzbl (%rax,%rsi), %eax
movl %eax, 0xc(%rsp)
movzbl (%r14,%rsi), %ecx
movl %ecx, 0x8(%rsp)
decq %rdx
cmpq %rdx, %rsi
jne 0x16f50
movl 0x20(%r15), %edx
xorl %esi, %esi
cmpq $0x6, %rdx
ja 0x16f1d
leaq 0x8847e(%rip), %rsi     # 0x9f398
movl (%rsi,%rdx,4), %esi
imull 0x24(%r15), %esi
imull 0x18(%r15), %esi
imull 0x1c(%r15), %esi
andl $0x7, %esi
je 0x16f50
movl $0x8, %edx
subl %esi, %edx
xorl %esi, %esi
btrl %esi, %eax
btrl %esi, %ecx
incq %rsi
cmpq %rsi, %rdx
jne 0x16f3a
movl %eax, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1518a
movq %r12, %rdi
leaq 0x607ef(%rip), %rsi     # 0x77765
callq 0x23e0
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x703b5
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x70057
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x70230
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x16fbc
callq 0x2210
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x16fd0
callq 0x2210
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x16fe4
callq 0x2210
movq 0x10(%rsp), %rsi
incq %rsi
movq %rsi, 0x10(%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
cmpq %rdx, %rsi
jb 0x16eee
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17015
movq %rax, %rbx
jmp 0x1704a
movq %rax, %rbx
jmp 0x17036
movq %rax, %rbx
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rax
cmpq %rax, %rdi
je 0x17036
callq 0x2210
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x1704a
callq 0x2210
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1705e
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: doCodecTest(Image&)
void doCodecTest(Image& image) {
  doCodecTestC(image);
  doCodecTestCPP(image);
  doCodecTestInterlaced(image);
  doCodecTestUncompressed(image);
  doCodecTestNoLZ77(image);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x17066
movq %rbx, %rdi
callq 0x17ca4
movq %rbx, %rdi
callq 0x1ac38
movq %rbx, %rdi
callq 0x19759
movq %rbx, %rdi
popq %rbx
jmp 0x197b8
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: codecTest(unsigned int, unsigned int, LodePNGColorType, unsigned int)
void codecTest(unsigned width, unsigned height, LodePNGColorType colorType = LCT_RGBA, unsigned bitDepth = 8) {
  std::cout << "codec test " << width << " " << height << std::endl;
  Image image;
  generateTestImage(image, width, height, colorType, bitDepth);
  doCodecTest(image);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x98570(%rip), %r12     # 0xb3fd8
leaq 0x5ab77(%rip), %rsi     # 0x765e6
movl $0xb, %edx
movq %r12, %rdi
callq 0x2280
movl %r15d, %esi
movq %r12, %rdi
callq 0x2160
movq %rax, %r12
leaq 0x5bcd4(%rip), %rsi     # 0x77765
movl $0x1, %edx
movq %rax, %rdi
callq 0x2280
movl %r14d, %esi
movq %r12, %rdi
callq 0x2160
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x1692e
movq %rsp, %rdi
callq 0x1ba21
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1bb0a
callq 0x2210
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1bb28
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: bitStringToBytes(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void bitStringToBytes(std::vector<unsigned char>& bytes, const std::string& bits_) {
  std::string bits = removeSpaces(bits_);
  bytes.resize((bits.size()) + 7 / 8);
  for(size_t i = 0; i < bits.size(); i++) {
    size_t j = i / 8;
    size_t k = i % 8;
    char c = bits[i];
    if(k == 0) bytes[j] = 0;
    if(c == '1') bytes[j] |= (1 << (7 - k));
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1bb30
movq 0x8(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1078a
cmpq $0x0, 0x10(%rsp)
je 0x1bc16
xorl %eax, %eax
movq %rax, %rdx
shrq $0x3, %rdx
movq %rax, %rcx
movq 0x8(%rsp), %rsi
movb (%rsi,%rax), %sil
andq $0x7, %rcx
jne 0x1bbf6
movq (%rbx), %rdi
movb $0x0, (%rdi,%rdx)
cmpb $0x31, %sil
jne 0x1bc0c
xorb $0x7, %cl
movb $0x1, %sil
shlb %cl, %sil
movq (%rbx), %rcx
orb %sil, (%rcx,%rdx)
incq %rax
cmpq 0x10(%rsp), %rax
jb 0x1bbd6
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bc29
callq 0x2210
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bc47
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testSinglePixel(int, int, int, int)
void testSinglePixel(int r, int g, int b, int a) {
  std::cout << "codec single pixel " << r << " " << g << " " << b << " " << a << std::endl;
  Image pixel;
  pixel.width = 1;
  pixel.height = 1;
  pixel.colorType = LCT_RGBA;
  pixel.bitDepth = 8;
  pixel.data.resize(4);
  pixel.data[0] = r;
  pixel.data[1] = g;
  pixel.data[2] = b;
  pixel.data[3] = a;

  doCodecTest(pixel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x97af0(%rip), %r12     # 0xb3fd8
leaq 0x5a15b(%rip), %rsi     # 0x7664a
movl $0x13, %edx
movq %r12, %rdi
callq 0x2280
movq %r12, %rdi
movl %r15d, %esi
callq 0x23a0
movq %rax, %r13
leaq 0x5b254(%rip), %r12     # 0x77765
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2280
movq %r13, %rdi
movl %r14d, %esi
callq 0x23a0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2280
movq %r13, %rdi
movl %ebp, %esi
callq 0x23a0
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2280
movq %r13, %rdi
movl %ebx, %esi
callq 0x23a0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movaps 0x59bc8(%rip), %xmm0    # 0x76170
movups %xmm0, 0x18(%rdi)
movl $0x4, %esi
xorl %edx, %edx
callq 0x1078a
movq %rsp, %rdi
movq (%rdi), %rax
movb %r15b, (%rax)
movq (%rdi), %rax
movb %r14b, 0x1(%rax)
movq (%rdi), %rax
movb %bpl, 0x2(%rax)
movq (%rdi), %rax
movb %bl, 0x3(%rax)
callq 0x1ba21
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c5e8
callq 0x2210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c608
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testSize(unsigned int, unsigned int)
void testSize(unsigned w, unsigned h) {
  std::cout << "codec test size " << w << " " << h << std::endl;
  Image image;
  image.width = w;
  image.height = h;
  image.colorType = LCT_RGBA;
  image.bitDepth = 8;
  image.data.resize(w * h * 4);
  for(size_t y = 0; y < h; y++)
  for(size_t x = 0; x < w; x++) {
    image.data[w * 4 * y + 4 * x + 0] = x & 255;
    image.data[w * 4 * y + 4 * x + 1] = y & 255;
    image.data[w * 4 * y + 4 * x + 2] = 255;
    image.data[w * 4 * y + 4 * x + 3] = 255;
  }

  doCodecTest(image);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x96e81(%rip), %r15     # 0xb3fd8
leaq 0x59529(%rip), %rsi     # 0x76687
movl $0x10, %edx
movq %r15, %rdi
callq 0x2280
movl %ebx, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %r12
leaq 0x5a5e2(%rip), %rsi     # 0x77765
movl $0x1, %edx
movq %rax, %rdi
callq 0x2280
movl %ebp, %r15d
movq %r12, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %ebx, 0x18(%rdi)
movl %ebp, 0x1c(%rdi)
movabsq $0x800000006, %rax      # imm = 0x800000006
movq %rax, 0x20(%rdi)
leal (,%rbx,4), %r12d
movl %r12d, %esi
imull %ebp, %esi
xorl %edx, %edx
callq 0x1078a
testl %ebp, %ebp
je 0x1d255
movl %r12d, %eax
xorl %ecx, %ecx
movb $-0x1, %dl
xorl %esi, %esi
testl %ebx, %ebx
je 0x1d24a
xorl %edi, %edi
movq %rcx, %r8
movq %r14, %r9
movq (%rsp), %r10
movb %dil, (%r10,%r8)
movq (%rsp), %r10
movb %sil, 0x1(%r10,%r8)
movq (%rsp), %r10
movb %dl, 0x2(%r10,%r8)
movq (%rsp), %r10
movb %dl, 0x3(%r10,%r8)
incb %dil
addq $0x4, %r8
decq %r9
jne 0x1d21b
incq %rsi
addq %rax, %rcx
cmpq %r15, %rsi
jne 0x1d20f
movq %rsp, %rdi
callq 0x1ba21
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d26b
callq 0x2210
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d289
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testDiskCompressZlib(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void testDiskCompressZlib(const std::string& filename) {
  std::cout << "testDiskCompressZlib: File " << filename << std::endl;

  std::vector<unsigned char> buffer;
  lodepng::load_file(buffer, filename);
  std::string f;
  for(size_t i = 0; i < buffer.size(); i++) f += (char)buffer[i];
  testCompressStringZlib(f, false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x9434a(%rip), %r14     # 0xb3fd8
leaq 0x571b4(%rip), %rsi     # 0x76e49
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2280
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2280
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rbx, %rsi
callq 0xd13e
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x1fd3d
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x21f0
incq %r15
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
cmpq %rcx, %r15
jb 0x1fd1c
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1ed09
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x1fd58
callq 0x2210
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fd66
callq 0x2210
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1fd77
movq %rax, %rbx
jmp 0x1fd89
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x1fd89
callq 0x2210
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1fd97
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: strtovector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<unsigned> strtovector(const std::string& numbers) {
  std::vector<unsigned> result;
  std::stringstream ss(numbers);
  unsigned i;
  while(ss >> i) result.push_back(i);
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
movl $0x18, %edx
callq 0x2330
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x23b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x20119
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2010c
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x200d9
movq %rbx, %rdi
movq %r15, %rdx
callq 0x70f4c
jmp 0x200d9
leaq 0x8(%rsp), %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x20145
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x21b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20152
callq 0x2210
movq %r14, %rdi
callq 0x23c0
movq %rax, %rdi
callq 0x14d36
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: extractChunkNames[abi:cxx11](std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::string extractChunkNames(const std::vector<unsigned char>& png) {
  const unsigned char* chunk = &png[8];
  const unsigned char* end = &png.back() + 1;
  char name[5];
  std::string result = "";
  for(;;) {
    lodepng_chunk_type(name, chunk);
    result += (std::string(" ") + name);
    if(std::string(name) == "IEND") break;
    chunk = lodepng_chunk_next_const(chunk, end);
    assertTrue(chunk < &png.back(), "jumped out of chunks");
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq (%rsi), %r12
movq 0x8(%rsi), %rax
movq %rax, 0x60(%rsp)
addq $0x8, %r12
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x564db(%rip), %rdx     # 0x77766
movq %rdi, 0x10(%rsp)
movq %rdx, %rsi
callq 0x14f6e
leaq 0x28(%rsp), %r15
leaq 0x3b(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq %r13, %rdi
movq %r12, %rsi
callq 0x544e
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x5649d(%rip), %rsi     # 0x77765
leaq 0x56497(%rip), %rdx     # 0x77766
callq 0x14f6e
movq %r15, 0x18(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x1518a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x23e0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rdi
callq 0x20c0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2131c
callq 0x2210
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x21330
callq 0x2210
movq %r15, 0x18(%rsp)
movq %r13, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x3b, %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x14f6e
movq %rbp, %rdi
leaq 0x55e42(%rip), %rsi     # 0x7719c
callq 0x20b0
movl %eax, %ebx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x21370
callq 0x2210
testl %ebx, %ebx
je 0x213cf
movq %r12, %rdi
movq 0x60(%rsp), %rsi
callq 0x55b2
movq %rax, %r12
movq 0x8(%r14), %rbx
movq %r15, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x55c6d(%rip), %rsi     # 0x77004
leaq 0x55c7a(%rip), %rdx     # 0x77018
callq 0x14f6e
decq %rbx
xorl %edi, %edi
cmpq %rbx, %r12
setb %dil
movq %rbp, %rsi
callq 0x162a1
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x212a7
callq 0x2210
jmp 0x212a7
movq 0x10(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21429
jmp 0x21415
jmp 0x21429
movq %rax, %r14
jmp 0x21402
jmp 0x213f0
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x21402
callq 0x2210
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
jne 0x21422
jmp 0x2142c
jmp 0x21429
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2142c
callq 0x2210
jmp 0x2142c
movq %rax, %r14
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq %rcx, %rdi
je 0x21443
callq 0x2210
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: addColor(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char, unsigned char, unsigned char, unsigned char)
void addColor(std::vector<unsigned char>& colors, unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
  colors.push_back(r);
  colors.push_back(g);
  colors.push_back(b);
  colors.push_back(a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
movb %sil, 0x7(%rsp)
movb %r15b, 0x6(%rsp)
movb %r14b, 0x5(%rsp)
movb %bpl, 0x4(%rsp)
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x38962
movb %sil, (%rax)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38976
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16120
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3898c
movb %r15b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3899d
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x389b3
movb %r14b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x389c4
leaq 0x5(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x389d3
movb %bpl, (%rsi)
incq 0x8(%rbx)
jmp 0x389e0
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: addColor16(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned short, unsigned short, unsigned short, unsigned short)
void addColor16(std::vector<unsigned char>& colors, unsigned short r, unsigned short g, unsigned short b, unsigned short a) {
  colors.push_back(r & 255);
  colors.push_back((r >> 8) & 255);
  colors.push_back(g & 255);
  colors.push_back((g >> 8) & 255);
  colors.push_back(b & 255);
  colors.push_back((b >> 8) & 255);
  colors.push_back(a & 255);
  colors.push_back((a >> 8) & 255);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movb %r12b, 0xf(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x38a25
movb %r12b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38a36
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
shrl $0x8, %r12d
movb %r12b, 0xe(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38a55
movb %r12b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38a66
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
movb %r15b, 0xd(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38a81
movb %r15b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38a92
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
shrl $0x8, %r15d
movb %r15b, 0xc(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38ab1
movb %r15b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38ac2
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
movb %r14b, 0xb(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38add
movb %r14b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38aee
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
shrl $0x8, %r14d
movb %r14b, 0xa(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38b0d
movb %r14b, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38b1e
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
movb %bpl, 0x9(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38b39
movb %bpl, (%rsi)
movq 0x8(%rbx), %rsi
incq %rsi
movq %rsi, 0x8(%rbx)
jmp 0x38b4a
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
movq 0x8(%rbx), %rsi
shrl $0x8, %ebp
movb %bpl, 0x8(%rsp)
cmpq 0x10(%rbx), %rsi
je 0x38b61
movb %bpl, (%rsi)
incq 0x8(%rbx)
jmp 0x38b6e
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x16120
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testSbitChunk(unsigned int, unsigned int, unsigned int, unsigned int, LodePNGColorType, unsigned int, bool)
void testSbitChunk(unsigned r, unsigned g, unsigned b, unsigned a,
                   LodePNGColorType type, unsigned bitdepth,
                   bool expect_encoder_error = false) {
  LodePNGColorMode mode_raw;
  lodepng_color_mode_init(&mode_raw);
  mode_raw.bitdepth = bitdepth;
  mode_raw.colortype = type;
  LodePNGColorMode mode_png;
  lodepng_color_mode_init(&mode_png);
  mode_png.bitdepth = bitdepth;
  mode_png.colortype = type;

  std::vector<unsigned char> pixels(8, 255); // force all pixels to be white, so encoder tries to use auto_convert as much as possible

  testSbitChunk(r, g, b, a, pixels, 1, 1, mode_raw, mode_png, false, expect_encoder_error);
  testSbitChunk(r, g, b, a, pixels, 1, 1, mode_raw, mode_png, true, expect_encoder_error);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, 0xc(%rsp)
movl %edx, %r12d
movl %esi, %r13d
movl %edi, %r15d
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x5861
movl %ebx, 0x4(%r14)
movl %ebp, (%r14)
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0x5861
movl %ebx, 0x4(%r14)
movl %ebp, (%r14)
leaq 0x10(%rsp), %rdi
leaq 0x3(%rsp), %rcx
movl $0x8, %esi
movl $0xff, %edx
callq 0x70e40
subq $0x8, %rsp
movzbl 0xb8(%rsp), %ebp
movl %r15d, 0xc(%rsp)
movl %r15d, %edi
movl %r13d, 0x10(%rsp)
movl %r13d, %esi
movl %r12d, %r13d
movl %r12d, %edx
movl 0x14(%rsp), %ecx
movl %ecx, %ebx
movq %r14, %r15
leaq 0x18(%rsp), %r8
leaq 0x30(%rsp), %r14
movl $0x1, %r9d
pushq %rbp
pushq $0x0
pushq %r15
pushq %r14
pushq $0x1
callq 0x52a38
addq $0x30, %rsp
subq $0x8, %rsp
leaq 0x18(%rsp), %r8
movl 0xc(%rsp), %edi
movl 0x10(%rsp), %esi
movl %r13d, %edx
movl %ebx, %ecx
movl $0x1, %r9d
pushq %rbp
movl $0x1, %eax
pushq %rax
pushq %r15
pushq %r14
pushq %rax
callq 0x52a38
addq $0x30, %rsp
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x550a4
callq 0x2210
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x550c5
callq 0x2210
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: doMain()
void doMain() {
  //PNG
  testPngSuite();
  testErrorImages();
  testPNGCodec();
  testPaletteFilterTypesZero();
  testComplexPNG();
  testInspectChunk();
  testPredefinedFilters();
  testFuzzing();
  testEncoderErrors();
  testPaletteToPaletteDecode();
  testPaletteToPaletteDecode2();
  testColorProfile();
  testExif();
  testBkgdChunk();
  testBkgdChunk2();
  testSbitChunk();

  //Colors
#ifndef DISABLE_SLOW
  testFewColors();
#endif // DISABLE_SLOW
  testColorKeyConvert();
  testColorConvert();
  testColorConvert2();
  testPaletteToPaletteConvert();
  testRGBToPaletteConvert();
  test16bitColorEndianness();
  testAutoColorModels();
  testNoAutoConvert();
  testChrmToSrgb();
  testXYZ();
  testICC();
  testICCGray();

  //Zlib
  testCompressZlib();
  testHuffmanCodeLengths();
  testCustomZlibCompress();
  testCustomZlibCompress2();
  testCustomDeflate();
  testCustomZlibDecompress();
  testCustomInflate();
  // TODO: add test for huffman code with exactly 0 and 1 symbols present

  //lodepng_util
  testChunkUtil();
  testGetFilterTypes();

  std::cout << "\ntest successful" << std::endl;
}

// Assembly:
pushq %rbx
callq 0x66fad
callq 0x6fdd9
callq 0x1d291
callq 0x29879
callq 0x2144b
callq 0x27b48
callq 0x35895
callq 0x2ec8b
callq 0x36066
callq 0x3b306
callq 0x3c4ed
callq 0x42aad
callq 0x4c8fc
callq 0x507ea
callq 0x50fa0
callq 0x55554
callq 0x1c94a
callq 0x2bbb4
callq 0x1d541
callq 0x1e6ed
callq 0x29ef7
callq 0x2b959
callq 0x332a0
callq 0x3a0c4
callq 0x2d67f
callq 0x596c1
callq 0x59be1
callq 0x5b1a1
callq 0x60b9c
callq 0x1f8ce
callq 0x206aa
callq 0x2f174
callq 0x2fb7b
callq 0x306ee
callq 0x310f5
callq 0x31d35
callq 0x32975
callq 0x19817
movq 0x44042(%rip), %rbx     # 0xb3fd8
leaq 0x2f095(%rip), %rsi     # 0x9f032
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2280
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
jmp 0x2170