LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4df4d(%rip), %r14     # 0x5fd30
leaq 0x24(%rsp), %r13
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x11b49
cvtss2sd 0x4(%rsp), %xmm0
cvtss2sd 0x8(%rsp), %xmm1
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 0x11b49
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
cmpq $0x3, %rax
je 0x11e95
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
jmp 0x11e59
leaq 0x4dec4(%rip), %rsi     # 0x5fd60
movq %rbx, %rdi
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12024
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::getChrmMatrixXYZ(float*, float, float, float, float, float, float, float, float, float, float, float, float)
static unsigned getChrmMatrixXYZ(float* m,
                                 float wX, float wY, float wZ,
                                 float rX, float rY, float rZ,
                                 float gX, float gY, float gZ,
                                 float bX, float bY, float bZ) {
  float t[9];
  float rs, gs, bs;
  t[0] = rX; t[1] = gX; t[2] = bX;
  t[3] = rY; t[4] = gY; t[5] = bY;
  t[6] = rZ; t[7] = gZ; t[8] = bZ;
  if(invMatrix(t)) return 1; /* error, not invertible */
  mulMatrix(&rs, &gs, &bs, t, wX, wY, wZ);
  m[0] = rs * rX; m[1] = gs * gX; m[2] = bs * bX;
  m[3] = rs * rY; m[4] = gs * gY; m[5] = bs * bY;
  m[6] = rs * rZ; m[7] = gs * gZ; m[8] = bs * bZ;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movss %xmm2, 0x10(%rsp)
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movss 0xd8(%rsp), %xmm0
movss 0xd0(%rsp), %xmm1
movss 0xc8(%rsp), %xmm8
movss 0xc0(%rsp), %xmm2
leaq 0x70(%rsp), %rdi
movaps %xmm3, 0x40(%rsp)
movss %xmm3, (%rdi)
movaps %xmm6, 0x30(%rsp)
movss %xmm6, 0x4(%rdi)
movss %xmm8, 0x8(%rdi)
movaps %xmm4, 0x20(%rsp)
movss %xmm4, 0xc(%rdi)
movaps %xmm7, 0x60(%rsp)
movss %xmm7, 0x10(%rdi)
movss %xmm1, 0x14(%rdi)
movaps %xmm5, 0x50(%rsp)
movss %xmm5, 0x18(%rdi)
movss %xmm2, 0x1c(%rdi)
movss %xmm0, 0x20(%rdi)
callq 0x11bca
testl %eax, %eax
je 0x11f59
pushq $0x1
popq %rax
jmp 0x12015
cvtss2sd 0x8(%rsp), %xmm0
cvtss2sd 0xc(%rsp), %xmm1
cvtss2sd 0x10(%rsp), %xmm2
leaq 0x1c(%rsp), %r14
leaq 0x18(%rsp), %r15
leaq 0x14(%rsp), %r12
leaq 0x70(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x11b49
movss (%r12), %xmm0
movss (%r15), %xmm1
movss (%r14), %xmm2
movaps %xmm2, %xmm3
unpcklps %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
movlhps %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
shufps $0x24, %xmm3, %xmm3     # xmm3 = xmm3[0,1,2,0]
movss 0xc8(%rsp), %xmm5
unpcklps 0x20(%rsp), %xmm5       # xmm5 = xmm5[0],mem[0],xmm5[1],mem[1]
movaps 0x40(%rsp), %xmm4
unpcklps 0x30(%rsp), %xmm4       # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
movlhps %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
mulps %xmm3, %xmm4
movups %xmm4, (%rbx)
unpcklps %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movlhps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0]
shufps $0x24, %xmm1, %xmm1     # xmm1 = xmm1[0,1,2,0]
movaps 0x50(%rsp), %xmm3
movss 0xc0(%rsp), %xmm2
unpcklps %xmm2, %xmm3            # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movaps 0x60(%rsp), %xmm2
movss 0xd0(%rsp), %xmm4
unpcklps %xmm4, %xmm2            # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
movlhps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0]
mulps %xmm1, %xmm2
movups %xmm2, 0x10(%rbx)
movss 0xd8(%rsp), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, 0x20(%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %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 0x11b49
leaq 0x4(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x1c(%rsp), %rdx
cvtss2sd 0x4(%r15), %xmm0
cvtss2sd 0x10(%r15), %xmm1
cvtss2sd 0x1c(%r15), %xmm2
movq %r14, %rcx
callq 0x11b49
leaq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x20(%rsp), %rdx
cvtss2sd 0x8(%r15), %xmm0
cvtss2sd 0x14(%r15), %xmm1
cvtss2sd 0x20(%r15), %xmm2
movq %r14, %rcx
callq 0x11b49
xorl %eax, %eax
cmpq $0x9, %rax
je 0x120c5
movss (%rsp,%rax,4), %xmm0
movss %xmm0, (%rbx,%rax,4)
incq %rax
jmp 0x120b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq $0x1
popq %rcx
testq %rdi, %rdi
je 0x120ec
xorl %eax, %eax
cmpl $0x0, 0xfc(%rdi)
je 0x120e3
retq
cmpl $0x0, 0xf4(%rdi)
je 0x120ef
movl %ecx, %eax
retq
cmpl $0x0, 0xc8(%rdi)
jne 0x120e2
cmpl $0x0, 0xd0(%rdi)
je 0x120ec
cmpl $0x7a26, 0xd4(%rdi)     # imm = 0x7A26
jne 0x120e2
cmpl $0x8084, 0xd8(%rdi)     # imm = 0x8084
jne 0x120e2
cmpl $0xfa00, 0xdc(%rdi)     # imm = 0xFA00
jne 0x120e2
cmpl $0x80e8, 0xe0(%rdi)     # imm = 0x80E8
jne 0x120e2
cmpl $0x7530, 0xe4(%rdi)     # imm = 0x7530
jne 0x120e2
cmpl $0xea60, 0xe8(%rdi)     # imm = 0xEA60
jne 0x120e2
cmpl $0x3a98, 0xec(%rdi)     # imm = 0x3A98
jne 0x120e2
cmpl $0x1770, 0xf0(%rdi)     # imm = 0x1770
jne 0x120e2
jmp 0x120ec
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: assertNoPNGError(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertNoPNGError(unsigned error, const std::string& message = "") {
  if(error) {
    std::string msg = (message == "") ? lodepng_error_text(error)
                                      : message + std::string(": ") + lodepng_error_text(error);
    assertEquals(0, error, msg);
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edi, 0x4(%rsp)
testl %edi, %edi
je 0x1340e
movq %rsi, %r14
movl %edi, %ebx
leaq 0x4e255(%rip), %rsi     # 0x615c6
movq %r14, %rdi
callq 0x121b0
testb %al, %al
je 0x13398
movl %ebx, %edi
callq 0xb5c9
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rax, %rsi
callq 0x20c0
jmp 0x133ed
leaq 0x50406(%rip), %rsi     # 0x637a5
leaq 0x48(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x20c0
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %r14, %rsi
callq 0x5a61f
movl %ebx, %edi
callq 0xb5c9
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x5a5df
leaq 0x8(%rsp), %rdi
callq 0x2270
leaq 0x48(%rsp), %rdi
callq 0x2270
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
leaq 0x4(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x5a65f
leaq 0x28(%rsp), %rdi
callq 0x2270
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2270
jmp 0x13446
movq %rax, %rbx
jmp 0x13446
movq %rax, %rbx
jmp 0x1343c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2270
leaq 0x48(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8fd04(%rip), %eax     # 0xa3208
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, 0x8fce9(%rip)     # 0xa3208
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13527
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, %ebx
shrl $0x8, %ebx
andl %eax, %ebx
movl %ebp, %r14d
shrl $0x10, %r14d
andl %eax, %r14d
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 0x4c943(%rip), %rsi     # 0x60184
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
pushq %r15
pushq %r13
pushq %r11
pushq %r10
pushq %rbp
pushq %r14
pushq %rbx
pushq 0x40(%rsp)
pushq %r12
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
callq 0x2060
addq $0x60, %rsp
leaq 0x3(%rsp), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
leaq 0x40(%rsp), %rsi
callq 0x20c0
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_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: generateTestImage(Image&, unsigned int, unsigned int, LodePNGColorType, unsigned int)
void generateTestImage(Image& image, unsigned width, unsigned height, LodePNGColorType colorType = LCT_RGBA, unsigned bitDepth = 8) {
  image.width = width;
  image.height = height;
  image.colorType = colorType;
  image.bitDepth = bitDepth;

  size_t bits = bitDepth * getNumColorChannels(colorType); //bits per pixel
  size_t size = (width * height * bits + 7) / 8; //total image size in bytes
  image.data.resize(size);
  unsigned char value = 128;
  for(size_t i = 0; i < size; i++) {
    image.data[i] = value++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
movl %ecx, 0x20(%rdi)
movl %r8d, 0x24(%rdi)
movl %ecx, %edi
callq 0x138b3
imull %ebp, %eax
imull %r15d, %ebx
imulq %rax, %rbx
addq $0x7, %rbx
shrq $0x3, %rbx
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xe6d8
cmpq %r15, %rbx
je 0x13928
leaq 0x80(%r15), %rax
movq (%r14), %rcx
movb %al, (%rcx,%r15)
incq %r15
jmp 0x13910
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
xorl %eax, %eax
leaq 0x48(%rsp), %r13
leaq 0x28(%rsp), %rbp
leaq 0x68(%rsp), %r12
movq %rax, 0x10(%rsp)
movq (%r15), %rdx
movq 0x8(%r15), %rcx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x13f4e
movzbl (%rdx,%rax), %ebx
movl %ebx, 0xc(%rsp)
movq 0x18(%rsp), %rdx
movzbl (%rdx,%rax), %r14d
movl %r14d, 0x8(%rsp)
decq %rcx
cmpq %rcx, %rax
jne 0x13ee8
movl 0x20(%r15), %edi
callq 0x138b3
imull 0x24(%r15), %eax
imull 0x18(%r15), %eax
imull 0x1c(%r15), %eax
andl $0x7, %eax
je 0x13ee8
pushq $0x8
popq %rcx
subl %eax, %ecx
xorl %eax, %eax
cmpq %rax, %rcx
je 0x13edf
btrl %eax, %ebx
btrl %eax, %r14d
incq %rax
jmp 0x13ece
movl %ebx, 0xc(%rsp)
movl %r14d, 0x8(%rsp)
movq %r13, %rdi
movq 0x20(%rsp), %rsi
leaq 0x4d6ce(%rip), %rdx     # 0x615c5
callq 0x5a5df
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x5a86b
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x5a61f
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x5a765
movq %r12, %rdi
callq 0x2270
movq %rbp, %rdi
callq 0x2270
movq %r13, %rdi
callq 0x2270
movq 0x10(%rsp), %rax
incq %rax
jmp 0x13e73
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2270
jmp 0x13f77
movq %rax, %rbx
jmp 0x13f81
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2270
leaq 0x48(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 0x13f9b
movq %rbx, %rdi
callq 0x14870
movq %rbx, %rdi
callq 0x16df7
movq %rbx, %rdi
callq 0x15cf7
movq %rbx, %rdi
popq %rbx
jmp 0x15d53
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x8b6c5(%rip), %rdi     # 0xa2fd8
leaq 0x48b2c(%rip), %rsi     # 0x60446
callq 0x21f0
movl %r15d, %esi
movq %rax, %rdi
callq 0x2140
leaq 0x49c94(%rip), %rsi     # 0x615c5
movq %rax, %rdi
callq 0x21f0
movl %r14d, %esi
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x2100
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x138c7
movq %rsp, %rdi
callq 0x178ce
movq %rsp, %rdi
callq 0xea7c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 0x179a0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xe6d8
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
jae 0x17a6c
movq %rax, %rdx
shrq $0x3, %rdx
movq %rax, %rcx
movq 0x8(%rsp), %rsi
movb (%rsi,%rax), %sil
andq $0x7, %rcx
jne 0x17a51
movq (%rbx), %rdi
movb $0x0, (%rdi,%rdx)
cmpb $0x31, %sil
jne 0x17a67
xorb $0x7, %cl
movb $0x1, %sil
shlb %cl, %sil
movq (%rbx), %rcx
orb %sil, (%rcx,%rdx)
incq %rax
jmp 0x17a2a
leaq 0x8(%rsp), %rdi
callq 0x2270
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testOtherPattern2()
void testOtherPattern2() {
  std::cout << "codec other pattern 2" << std::endl;

  Image image1;
  size_t w = 192;
  size_t h = 192;
  image1.width = w;
  image1.height = h;
  image1.colorType = LCT_RGBA;
  image1.bitDepth = 8;
  image1.data.resize(w * h * 4u);
  for(size_t y = 0; y < h; y++)
  for(size_t x = 0; x < w; x++) {
    image1.data[4u * w * y + 4u * x + 0u] = 255 * !(x & y);
    image1.data[4u * w * y + 4u * x + 1u] = x ^ y;
    image1.data[4u * w * y + 4u * x + 2u] = x | y;
    image1.data[4u * w * y + 4u * x + 3u] = 255;
  }

  doCodecTest(image1);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq 0x8af46(%rip), %rdi     # 0xa2fd8
leaq 0x483fb(%rip), %rsi     # 0x60494
callq 0x21f0
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps 0x47f55(%rip), %xmm0    # 0x60010
movups %xmm0, 0x18(%rdi)
xorl %ebx, %ebx
movl $0x24000, %esi          # imm = 0x24000
xorl %edx, %edx
callq 0xe6d8
xorl %eax, %eax
cmpq $0xc0, %rax
je 0x18138
xorl %ecx, %ecx
cmpq $0xc0, %rcx
je 0x1812c
movq %rcx, %rdx
andq %rax, %rdx
cmpq $0x1, %rdx
movl $0x0, %edx
sbbl %edx, %edx
movq (%rsp), %rsi
addq %rbx, %rsi
movb %dl, (%rsi,%rcx,4)
movl %ecx, %edx
xorl %eax, %edx
movq (%rsp), %rsi
addq %rbx, %rsi
movb %dl, 0x1(%rsi,%rcx,4)
movl %ecx, %edx
orl %eax, %edx
movq (%rsp), %rsi
addq %rbx, %rsi
movb %dl, 0x2(%rsi,%rcx,4)
movq (%rsp), %rdx
addq %rbx, %rdx
movb $-0x1, 0x3(%rdx,%rcx,4)
incq %rcx
jmp 0x180d9
incq %rax
addq $0x300, %rbx            # imm = 0x300
jmp 0x180cf
movq %rsp, %rdi
callq 0x178ce
movq %rsp, %rdi
callq 0xea7c
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x8ae52(%rip), %rdi     # 0xa2fd8
leaq 0x4831d(%rip), %rsi     # 0x604aa
callq 0x21f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x2360
leaq 0x49421(%rip), %r12     # 0x615c5
movq %rax, %rdi
movq %r12, %rsi
callq 0x21f0
movq %rax, %rdi
movl %r14d, %esi
callq 0x2360
movq %rax, %rdi
movq %r12, %rsi
callq 0x21f0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2360
movq %rax, %rdi
movq %r12, %rsi
callq 0x21f0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2360
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movaps 0x47e1f(%rip), %xmm0    # 0x60020
movups %xmm0, 0x18(%rdi)
pushq $0x4
popq %rsi
xorl %edx, %edx
callq 0xe6d8
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 0x178ce
movq %rsp, %rdi
callq 0xea7c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movl %esi, %r15d
movl %edi, %ebp
movq 0x8a6e5(%rip), %rdi     # 0xa2fd8
leaq 0x47bed(%rip), %rsi     # 0x604e7
callq 0x21f0
movl %ebp, %ebx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
leaq 0x48cb2(%rip), %rsi     # 0x615c5
movq %rax, %rdi
callq 0x21f0
movl %r15d, %r14d
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movl %ebp, 0x18(%rdi)
movl %r15d, 0x1c(%rdi)
movabsq $0x800000006, %rax      # imm = 0x800000006
movq %rax, 0x20(%rdi)
shll $0x2, %ebp
imull %ebp, %r15d
movq %r15, %rsi
xorl %edx, %edx
callq 0xe6d8
movl %ebp, %eax
xorl %ecx, %ecx
movb $-0x1, %dl
xorl %esi, %esi
cmpq %r14, %rsi
je 0x189b4
xorl %edi, %edi
movq %rcx, %r8
movq %rbx, %r9
subq $0x1, %r9
jb 0x189ac
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)
addq $0x4, %r8
incb %dil
jmp 0x1897a
incq %rsi
addq %rax, %rcx
jmp 0x1896d
movq %rsp, %rdi
callq 0x178ce
movq %rsp, %rdi
callq 0xea7c
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x87fab(%rip), %rdi     # 0xa2fd8
leaq 0x45c75(%rip), %rsi     # 0x60ca9
callq 0x21f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2100
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rbx, %rsi
callq 0xb5e7
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r14d, %r14d
leaq 0x18(%rsp), %rbx
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
cmpq %rcx, %r14
jae 0x1b09e
movsbl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x21b0
incq %r14
jmp 0x1b07b
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1a35e
leaq 0x18(%rsp), %rdi
callq 0x2270
movq %rsp, %rdi
callq 0xea7c
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x1b0c8
jmp 0x1b0cd
movq %rax, %rbx
jmp 0x1b0da
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2270
movq %rsp, %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testDiskPNG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void testDiskPNG(const std::string& filename) {
  std::cout << "testDiskPNG: File " << filename << std::endl;

  Image image;
  image.colorType = LCT_RGB;
  image.bitDepth = 8;
  unsigned error = lodepng::decode(image.data, image.width, image.height, filename, image.colorType, image.bitDepth);
  ASSERT_NO_PNG_ERROR(error);

  doCodecTest(image);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movq 0x87ed2(%rip), %rdi     # 0xa2fd8
leaq 0x45bb8(%rip), %rsi     # 0x60cc5
callq 0x21f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2100
xorps %xmm0, %xmm0
leaq 0x68(%rsp), %rsi
andq $0x0, -0x8(%rsi)
movaps %xmm0, -0x18(%rsi)
movabsq $0x800000002, %rax      # imm = 0x800000002
movq %rax, 0x8(%rsi)
leaq 0x6c(%rsp), %rdx
leaq 0x50(%rsp), %rdi
pushq $0x2
popq %r8
pushq $0x8
popq %r9
movq %rbx, %rcx
callq 0xba05
movl %eax, %ebx
leaq 0x45076(%rip), %rsi     # 0x601dd
leaq 0x98(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x20c0
leaq 0x45b58(%rip), %rdx     # 0x60cd8
leaq 0xb8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x5a5df
leaq 0x4642a(%rip), %rsi     # 0x615c6
leaq 0x78(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x20c0
movq 0x80(%rsp), %r14
testq %r14, %r14
je 0x1b1e6
leaq 0x46407(%rip), %rsi     # 0x615c6
leaq 0x10(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x20c0
leaq 0x485d0(%rip), %rsi     # 0x637a5
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x5a8d9
jmp 0x1b1fc
leaq 0x463d9(%rip), %rsi     # 0x615c6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x20c0
leaq 0xd8(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x5a61f
leaq 0xd8(%rsp), %rsi
movl %ebx, %edi
callq 0x13352
leaq 0xd8(%rsp), %rdi
callq 0x2270
leaq 0x30(%rsp), %rdi
callq 0x2270
testq %r14, %r14
je 0x1b24b
leaq 0x10(%rsp), %rdi
callq 0x2270
leaq 0x78(%rsp), %rdi
callq 0x2270
leaq 0xb8(%rsp), %rdi
callq 0x2270
leaq 0x98(%rsp), %rdi
callq 0x2270
leaq 0x50(%rsp), %rdi
callq 0x178ce
leaq 0x50(%rsp), %rdi
callq 0xea7c
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
jmp 0x1b2ac
movq %rax, %rbx
jmp 0x1b2cd
movq %rax, %rbx
jmp 0x1b2c8
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x2270
jmp 0x1b2be
movq %rax, %rbx
jmp 0x1b2d7
movq %rax, %rbx
jmp 0x1b2ee
movq %rax, %rbx
jmp 0x1b2e1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2270
testq %r14, %r14
je 0x1b2d7
leaq 0x10(%rsp), %rdi
callq 0x2270
leaq 0x78(%rsp), %rdi
callq 0x2270
leaq 0xb8(%rsp), %rdi
callq 0x2270
leaq 0x98(%rsp), %rdi
callq 0x2270
jmp 0x1b302
jmp 0x1b2ff
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x2300
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2370
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1b373
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5ab98
jmp 0x1b34d
leaq 0x8(%rsp), %rdi
callq 0x2170
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x1b39f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x5b198
movq %r14, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x18(%rsp)
addq $0x8, %r12
leaq 0x45227(%rip), %rsi     # 0x615c6
leaq 0x28(%rsp), %r13
movq %rdi, 0x10(%rsp)
movq %r13, %rdx
callq 0x20c0
leaq 0x23(%rsp), %rbp
leaq 0x48(%rsp), %rbx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4574
movq %rbx, %rdi
leaq 0x451f5(%rip), %rsi     # 0x615c5
leaq 0xf(%rsp), %rdx
callq 0x20c0
movq %r13, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x5a5df
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x23c0
movq %r13, %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2270
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x20c0
movq %r13, %rdi
leaq 0x44bdf(%rip), %rsi     # 0x60ffc
callq 0x121b0
movl %eax, %r15d
movq %r13, %rdi
callq 0x2270
testb %r15b, %r15b
jne 0x1c479
movq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x4705
movq %rax, %r12
movq 0x8(%r14), %r15
movq %r13, %rdi
leaq 0x44a14(%rip), %rsi     # 0x60e64
movq %rbx, %rdx
callq 0x20c0
decq %r15
xorl %edi, %edi
cmpq %r15, %r12
setb %dil
movq %r13, %rsi
callq 0x1330f
movq %r13, %rdi
callq 0x2270
jmp 0x1c3bb
movq 0x10(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2270
jmp 0x1c4d2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2270
jmp 0x1c4c1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2270
jmp 0x1c4d2
jmp 0x1c4cf
jmp 0x1c4cf
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2270
jmp 0x1c4d2
jmp 0x1c4cf
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testRGBToPaletteConvert()
void testRGBToPaletteConvert() {
  unsigned char palette1[4] = {1,2,3,4};
  doRGBAToPaletteTest(palette1, 1);
  unsigned char palette2[8] = {1,2,3,4, 5,6,7,8};
  doRGBAToPaletteTest(palette2, 2);
  unsigned char palette3[12] = {1,1,1,255, 20,20,20,255, 20,20,21,255};
  doRGBAToPaletteTest(palette3, 3);

  std::vector<unsigned char> palette;
  for(int i = 0; i < 256; i++) {
    palette.push_back(i);
    palette.push_back(5);
    palette.push_back(6);
    palette.push_back(128);
  }
  doRGBAToPaletteTest(&palette[0], 256);
  palette.push_back(5);
  palette.push_back(6);
  palette.push_back(7);
  palette.push_back(8);
  doRGBAToPaletteTest(&palette[0], 257, LCT_RGBA);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x34(%rsp), %rdi
movl $0x4030201, (%rdi)      # imm = 0x4030201
pushq $0x1
popq %rsi
pushq $0x3
popq %rbx
movl %ebx, %edx
callq 0x23e82
movabsq $0x807060504030201, %rax # imm = 0x807060504030201
leaq 0x38(%rsp), %rdi
movq %rax, (%rdi)
pushq $0x2
popq %rsi
movl %ebx, %edx
callq 0x23e82
leaq 0x6444a(%rip), %rdi     # 0x891d4
pushq $0x3
popq %rsi
movl %ebx, %edx
callq 0x23e82
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %ebp, %ebp
leaq 0xf(%rsp), %r14
cmpl $0x100, %ebp            # imm = 0x100
je 0x24df7
movb %bpl, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1231e
movb $0x5, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1231e
movb $0x6, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1231e
movb $-0x80, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1231e
incl %ebp
jmp 0x24dab
movq 0x10(%rsp), %rdi
pushq $0x3
popq %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x23e82
leaq 0xf(%rsp), %rsi
movb $0x5, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1231e
leaq 0xf(%rsp), %rsi
movb $0x6, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1231e
leaq 0xf(%rsp), %rsi
movb $0x7, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1231e
leaq 0xf(%rsp), %rsi
movb $0x8, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1231e
movq 0x10(%rsp), %rdi
pushq $0x6
popq %rdx
movl $0x101, %esi            # imm = 0x101
callq 0x23e82
leaq 0x10(%rsp), %rdi
callq 0xea7c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x24e86
jmp 0x24e86
jmp 0x24e86
jmp 0x24e86
jmp 0x24e86
jmp 0x24e86
jmp 0x24e86
jmp 0x24e86
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rax
movb %sil, (%rax)
leaq 0x6(%rsp), %r14
movb %dl, (%r14)
leaq 0x5(%rsp), %r15
movb %cl, (%r15)
leaq 0x4(%rsp), %r12
movb %r8b, (%r12)
movq %rax, %rsi
callq 0x1231e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1231e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1231e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1231e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %eax
movq %rdi, %rbx
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl %eax, %r12d
callq 0x1231e
movl %r12d, %eax
movb %ah, 0xb(%rsp)
leaq 0xb(%rsp), %rsi
movq %rbx, %rdi
callq 0x1231e
leaq 0xe(%rsp), %rsi
movb %r15b, (%rsi)
movq %rbx, %rdi
callq 0x1231e
movl %r15d, %eax
movb %ah, 0xa(%rsp)
leaq 0xa(%rsp), %rsi
movq %rbx, %rdi
callq 0x1231e
leaq 0xd(%rsp), %rsi
movb %r14b, (%rsi)
movq %rbx, %rdi
callq 0x1231e
movl %r14d, %eax
movb %ah, 0x9(%rsp)
leaq 0x9(%rsp), %rsi
movq %rbx, %rdi
callq 0x1231e
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movq %rbx, %rdi
callq 0x1231e
movl %ebp, %eax
movb %ah, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1231e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13d
movl %esi, %r15d
movl %edi, %r14d
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x4970
movl %ebx, 0x4(%r12)
movl %ebp, (%r12)
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x4970
movl %ebx, 0x4(%r12)
movl %ebp, (%r12)
leaq 0x10(%rsp), %rdi
pushq $0x8
popq %rsi
leaq 0x3(%rsp), %rcx
movl $0xff, %edx
callq 0x5b028
subq $0x8, %rsp
movzbl 0xb8(%rsp), %ebx
pushq $0x1
popq %rax
movl %r14d, 0xc(%rsp)
movl %r14d, %edi
movl %r15d, 0x10(%rsp)
movl %r15d, %esi
movl %r13d, %r14d
movl %r13d, %edx
movq %rax, %r13
movl 0x14(%rsp), %ecx
movl %ecx, %ebp
leaq 0x18(%rsp), %r8
leaq 0x30(%rsp), %r15
movl %r13d, %r9d
pushq %rbx
pushq $0x0
pushq %r12
pushq %r15
pushq $0x1
callq 0x425be
addq $0x30, %rsp
subq $0x8, %rsp
leaq 0x18(%rsp), %r8
movl 0xc(%rsp), %edi
movl 0x10(%rsp), %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %r13d, %r9d
pushq %rbx
pushq %r13
pushq %r12
pushq %r15
pushq %r13
callq 0x425be
addq $0x30, %rsp
leaq 0x10(%rsp), %rdi
callq 0xea7c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xea7c
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: main
int main() {
  try {
    doMain();
  }
  catch(...) {
    std::cout << std::endl;
    std::cout << "caught error!" << std::endl;
    std::cout << "*** TEST FAILED ***" << std::endl;
  }

  return 0;
}

// Assembly:
pushq %rbx
callq 0x5a491
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rdi
callq 0x20d0
movq 0x48a53(%rip), %rdi     # 0xa2fd8
callq 0x2100
movq 0x48a47(%rip), %rdi     # 0xa2fd8
leaq 0x2e90b(%rip), %rsi     # 0x88ea3
callq 0x21f0
movq %rax, %rdi
callq 0x2100
movq 0x48a2c(%rip), %rdi     # 0xa2fd8
leaq 0x2e8fe(%rip), %rsi     # 0x88eb1
callq 0x21f0
movq %rax, %rdi
callq 0x2100
callq 0x2320
jmp 0x5a572
movq %rax, %rbx
callq 0x2320
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: void assertEquals<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void assertEquals(const T& expected, const U& actual, const std::string& message = "") {
  if(expected != (T)actual) {
    std::cout << "Error: Not equal! Expected " << valtostr(expected)
              << " got " << valtostr((T)actual) << ". "
              << "Message: " << message << std::endl;
    fail();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x22a0
movq %r15, %rdi
movq %r12, %rsi
callq 0x5ad6f
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2270
testb %bpl, %bpl
jne 0x5ac63
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4836e(%rip), %rdi     # 0xa2fd8
leaq 0x2e28a(%rip), %rsi     # 0x88efb
callq 0x21f0
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x5ad79
movq %r12, %rdi
movq %r13, %rsi
callq 0x21d0
leaq 0x55a6(%rip), %rsi      # 0x60241
movq %rax, %rdi
callq 0x21f0
movq %rax, %r15
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x22a0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x5ad79
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
callq 0x21d0
leaq 0x544e(%rip), %rsi      # 0x60124
movq %rax, %rdi
callq 0x21f0
leaq 0x5442(%rip), %rsi      # 0x60127
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21d0
movq %rax, %rdi
callq 0x2100
leaq 0x48(%rsp), %rdi
callq 0x2270
leaq 0x28(%rsp), %rdi
callq 0x2270
leaq 0x8(%rsp), %rdi
callq 0x2270
callq 0x13280
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2270
jmp 0x5ad35
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2270
jmp 0x5ad46
jmp 0x5ad43
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2270
jmp 0x5ad5f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x2380
movq %rax, %rdi
callq 0xe6cc
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: void fromBase64<std::vector<unsigned char, std::allocator<unsigned char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::vector<unsigned char, std::allocator<unsigned char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void fromBase64(T& out, const U& in) {
  for(size_t i = 0; i + 3 < in.size(); i += 4) {
    int v = 262144 * fromBase64(in[i]) + 4096 * fromBase64(in[i + 1]) + 64 * fromBase64(in[i + 2]) + fromBase64(in[i + 3]);
    out.push_back((v >> 16) & 0xff);
    if(in[i + 2] != '=') out.push_back((v >> 8) & 0xff);
    if(in[i + 3] != '=') out.push_back((v >> 0) & 0xff);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r15
pushq $0x3
popq %r14
movq %rsi, 0x10(%rsp)
cmpq 0x8(%r12), %r14
jae 0x5aa9d
movq (%r12), %r13
movsbl -0x3(%r13,%r14), %edi
callq 0x134c5
movq %r15, %r12
movl %eax, %r15d
shll $0x12, %r15d
movsbl -0x2(%r13,%r14), %edi
callq 0x134c5
movl %eax, %ebx
shll $0xc, %ebx
orl %ebx, %r15d
movsbl -0x1(%r13,%r14), %edi
callq 0x134c5
movl %eax, %ebp
shll $0x6, %ebp
movsbl (%r13,%r14), %edi
callq 0x134c5
movl %eax, %r13d
shrl $0x10, %r15d
movb %r15b, 0xf(%rsp)
movq %r12, %r15
movq 0x10(%rsp), %r12
movq %r15, %rdi
leaq 0xf(%rsp), %rsi
callq 0x1231e
movq (%r12), %rax
cmpb $0x3d, -0x1(%rax,%r14)
je 0x5aa78
orl %ebp, %ebx
movb %bh, 0xe(%rsp)
movq %r15, %rdi
leaq 0xe(%rsp), %rsi
callq 0x1231e
movq (%r12), %rax
cmpb $0x3d, (%rax,%r14)
je 0x5aa94
orl %ebp, %r13d
movb %r13b, 0xd(%rsp)
movq %r15, %rdi
leaq 0xd(%rsp), %rsi
callq 0x1231e
addq $0x4, %r14
jmp 0x5a9e2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::swap(net::selector::EPollSelector&)
void EPollSelector::swap(EPollSelector &other){
	using std::swap;

	swap(epollFD_		, other.epollFD_	);
	swap(statusData_	, other.statusData_	);
	swap(statusCount_	, other.statusCount_	);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl (%rsi), %ecx
movl %ecx, (%rdi)
movl %eax, (%rsi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x3786
movl 0x20(%r14), %eax
movl 0x20(%rbx), %ecx
movl %ecx, 0x20(%r14)
movl %eax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::wait(int)
WaitStatus EPollSelector::wait(int const timeout){
	if (epollFD_ < 0)
		return WaitStatus::ERROR;

	statusCount_ = epoll_wait(epollFD_, statusData_.data(), (int) statusData_.size(), timeout);

	if (statusCount_ < 0)
		return WaitStatus::ERROR;

	if (statusCount_ == 0)
		return WaitStatus::NONE;

	return WaitStatus::OK;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %edi
pushq $0x2
popq %rbx
testl %edi, %edi
js 0x352f
movl %esi, %ecx
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
pushq $0xc
popq %r8
cqto
idivq %r8
movl %eax, %edx
callq 0x2120
movl %eax, 0x20(%r14)
testl %eax, %eax
js 0x352f
sete %al
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::getFDStatus(unsigned int) const
FDResult EPollSelector::getFDStatus(uint32_t const no) const{
	if (no < (uint32_t) statusCount_){
		const epoll_event &ev = statusData_[no];

		int const fd = ev.data.fd;

		if (ev.events & EPOLLERR)
			return { fd, FDStatus::ERROR };

		if ((ev.events & EPOLLIN) || (ev.events & EPOLLHUP))
			return { fd, FDStatus::READ };

		if (ev.events & EPOLLOUT)
			return { fd, FDStatus::WRITE };
	}

	return FDStatus::STOP;
}

// Assembly:
movabsq $0x400000000, %rcx      # imm = 0x400000000
cmpl %esi, 0x20(%rdi)
jbe 0x3570
movl %esi, %eax
movq 0x8(%rdi), %rsi
imulq $0xc, %rax, %rax
movl (%rsi,%rax), %edx
movl 0x4(%rsi,%rax), %eax
testb $0x8, %dl
jne 0x3575
testb $0x11, %dl
je 0x3581
movabsq $0x100000000, %rcx      # imm = 0x100000000
jmp 0x359b
pushq $-0x1
popq %rax
jmp 0x359b
movabsq $0x300000000, %rcx      # imm = 0x300000000
jmp 0x359b
andl $0x4, %edx
movabsq $0x200000000, %rsi      # imm = 0x200000000
cmovneq %rsi, %rcx
xorl %esi, %esi
cmpl $0x1, %edx
sbbl %esi, %esi
orl %esi, %eax
movl %eax, %eax
orq %rcx, %rax
retq
nop