LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movss 0x28(%rbp), %xmm8
movss 0x20(%rbp), %xmm8
movss 0x18(%rbp), %xmm8
movss 0x10(%rbp), %xmm8
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movss %xmm2, -0x1c(%rbp)
movss %xmm3, -0x20(%rbp)
movss %xmm4, -0x24(%rbp)
movss %xmm5, -0x28(%rbp)
movss %xmm6, -0x2c(%rbp)
movss %xmm7, -0x30(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x60(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
movss 0x18(%rbp), %xmm0
movss %xmm0, -0x58(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
movss 0x20(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
movss 0x10(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movss 0x28(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x22250
cmpl $0x0, %eax
je 0x229d0
movl $0x1, -0x4(%rbp)
jmp 0x22ab1
leaq -0x60(%rbp), %rcx
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0x18(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movss -0x1c(%rbp), %xmm2
cvtss2sd %xmm2, %xmm2
leaq -0x64(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x6c(%rbp), %rdx
callq 0x21b80
movss -0x64(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x68(%rbp), %xmm0
mulss -0x2c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x6c(%rbp), %xmm0
mulss 0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x64(%rbp), %xmm0
mulss -0x24(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0xc(%rax)
movss -0x68(%rbp), %xmm0
mulss -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x6c(%rbp), %xmm0
mulss 0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x14(%rax)
movss -0x64(%rbp), %xmm0
mulss -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x18(%rax)
movss -0x68(%rbp), %xmm0
mulss 0x10(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x1c(%rax)
movss -0x6c(%rbp), %xmm0
mulss 0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
addq $0xc, %rsi
leaq -0x40(%rbp), %rdx
addq $0x18, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x18(%rbp), %rax
movss 0x18(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
callq 0x21b80
leaq -0x40(%rbp), %rdi
addq $0x4, %rdi
leaq -0x40(%rbp), %rsi
addq $0x10, %rsi
leaq -0x40(%rbp), %rdx
addq $0x1c, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x18(%rbp), %rax
movss 0x1c(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
callq 0x21b80
leaq -0x40(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
addq $0x14, %rsi
leaq -0x40(%rbp), %rdx
addq $0x20, %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movq -0x18(%rbp), %rax
movss 0x20(%rax), %xmm2
cvtss2sd %xmm2, %xmm2
callq 0x21b80
movl $0x0, -0x1c(%rbp)
cmpl $0x9, -0x1c(%rbp)
jge 0x22bd6
movslq -0x1c(%rbp), %rax
movss -0x40(%rbp,%rax,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x22bae
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2304b
movl $0x1, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0x0, 0xfc(%rax)
je 0x23064
movl $0x0, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0x0, 0xf4(%rax)
je 0x2307d
movl $0x1, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc8(%rax)
je 0x23096
movl $0x0, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0x0, 0xd0(%rax)
je 0x23150
movq -0x10(%rbp), %rax
cmpl $0x7a26, 0xd4(%rax)     # imm = 0x7A26
jne 0x230c7
movq -0x10(%rbp), %rax
cmpl $0x8084, 0xd8(%rax)     # imm = 0x8084
je 0x230d3
movl $0x0, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0xfa00, 0xdc(%rax)     # imm = 0xFA00
jne 0x230f3
movq -0x10(%rbp), %rax
cmpl $0x80e8, 0xe0(%rax)     # imm = 0x80E8
je 0x230fc
movl $0x0, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0x7530, 0xe4(%rax)     # imm = 0x7530
jne 0x2311c
movq -0x10(%rbp), %rax
cmpl $0xea60, 0xe8(%rax)     # imm = 0xEA60
je 0x23125
movl $0x0, -0x4(%rbp)
jmp 0x23157
movq -0x10(%rbp), %rax
cmpl $0x3a98, 0xec(%rax)     # imm = 0x3A98
jne 0x23145
movq -0x10(%rbp), %rax
cmpl $0x1770, 0xf0(%rax)     # imm = 0x1770
je 0x2314e
movl $0x0, -0x4(%rbp)
jmp 0x23157
jmp 0x23150
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl 0xcf176(%rip), %eax     # 0xf8270
shll $0xd, %eax
xorl 0xcf16d(%rip), %eax     # 0xf8270
movl %eax, 0xcf167(%rip)     # 0xf8270
movl 0xcf161(%rip), %eax     # 0xf8270
shrl $0x11, %eax
xorl 0xcf158(%rip), %eax     # 0xf8270
movl %eax, 0xcf152(%rip)     # 0xf8270
movl 0xcf14c(%rip), %eax     # 0xf8270
shll $0x5, %eax
xorl 0xcf143(%rip), %eax     # 0xf8270
movl %eax, 0xcf13d(%rip)     # 0xf8270
movl 0xcf137(%rip), %eax     # 0xf8270
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x34(%rbp), %r8
leaq -0x38(%rbp), %r9
callq 0x29170
movl -0x2c(%rbp), %ebx
movb %bl, %al
movzbl %al, %edx
movb %bh, %al
movzbl %al, %eax
movl %eax, -0x94(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movzbl %al, %r8d
shrl $0x18, %ebx
movl -0x30(%rbp), %eax
movb %al, %cl
movzbl %cl, %r10d
movb %ah, %cl
movzbl %cl, %ecx
movl %ecx, -0x98(%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %esi
shrl $0x18, %eax
movl %eax, -0x9c(%rbp)
movl -0x34(%rbp), %eax
movb %al, %cl
movzbl %cl, %r11d
movb %ah, %cl
movzbl %cl, %ecx
movl %ecx, -0xa0(%rbp)
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %edi
shrl $0x18, %eax
movl %eax, -0xa4(%rbp)
movl -0x38(%rbp), %ecx
movb %cl, %al
movzbl %al, %r14d
movb %ch, %al
movzbl %al, %eax
movl %eax, -0xa8(%rbp)
movl %ecx, %eax
shrl $0x10, %eax
movzbl %al, %r9d
shrl $0x18, %ecx
movq %rsp, %rax
movq %rax, -0xb0(%rbp)
movl %ecx, 0x58(%rax)
movl -0xa8(%rbp), %ecx
movl %ecx, 0x48(%rax)
movl -0xa4(%rbp), %ecx
movl %r14d, 0x40(%rax)
movl %ecx, 0x38(%rax)
movl -0xa0(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl -0x9c(%rbp), %ecx
movl %r11d, 0x20(%rax)
movl %ecx, 0x18(%rax)
movl -0x98(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x94(%rbp), %ecx
movl %r10d, (%rax)
movl %r9d, 0x50(%rax)
movl %edi, 0x30(%rax)
movl %esi, 0x10(%rax)
leaq 0x897bf(%rip), %rsi     # 0xb30bc
xorl %eax, %eax
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl %ebx, %r9d
callq 0x3070
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3440
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x3340
jmp 0x29938
leaq -0x61(%rbp), %rdi
callq 0x3290
movq -0xb8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x3290
movq -0x70(%rbp), %rdi
callq 0x3430
nopw %cs:(%rax,%rax)
// File: lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: getNumColorChannels(unsigned int)
unsigned getNumColorChannels(unsigned colorType) {
  switch(colorType) {
    case 0: return 1; /*gray*/
    case 2: return 3; /*RGB*/
    case 3: return 1; /*palette*/
    case 4: return 2; /*gray + alpha*/
    case 6: return 4; /*RGBA*/
  }
  return 0; /*unexisting color type*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0x29a25
movq -0x10(%rbp), %rax
leaq 0x89331(%rip), %rcx     # 0xb2d20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x29a2c
movl $0x3, -0x4(%rbp)
jmp 0x29a2c
movl $0x1, -0x4(%rbp)
jmp 0x29a2c
movl $0x2, -0x4(%rbp)
jmp 0x29a2c
movl $0x4, -0x4(%rbp)
jmp 0x29a2c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %edi
callq 0x299d0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
imull %ecx, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, %eax
imulq -0x20(%rbp), %rax
addq $0x7, %rax
shrq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x1a540
movb $-0x80, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x29b07
movb -0x29(%rbp), %al
movb %al, -0x3d(%rbp)
addb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a5f0
movb -0x3d(%rbp), %cl
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x29ad2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2a980
movq -0x8(%rbp), %rdi
callq 0x2ba40
movq -0x8(%rbp), %rdi
callq 0x2fb40
movq -0x8(%rbp), %rdi
callq 0x2df10
movq -0x8(%rbp), %rdi
callq 0x2dfa0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq 0xc70dd(%rip), %rdi     # 0xf7fd8
leaq 0x8247c(%rip), %rsi     # 0xb337e
callq 0x3230
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x3310
movq %rax, %rdi
leaq 0x835e7(%rip), %rsi     # 0xb4503
callq 0x3230
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x3310
movq %rax, %rdi
movq 0xc708a(%rip), %rsi     # 0xf7fc0
callq 0x3280
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xaaae0
movq -0x50(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
callq 0x29a40
jmp 0x30f60
leaq -0x38(%rbp), %rdi
callq 0x30ea0
jmp 0x30f6b
leaq -0x38(%rbp), %rdi
callq 0xaab00
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xaab00
jmp 0x30f91
jmp 0x30f93
movq -0x40(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x30fb0
movq -0x78(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
callq 0x3190
movq %rax, -0x68(%rbp)
jmp 0x310db
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
xorl %edx, %edx
callq 0x1a540
jmp 0x310ec
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3190
movq %rax, -0x80(%rbp)
jmp 0x3110e
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
cmpq %rcx, %rax
jae 0x311f5
movq -0x48(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
andl $0x7, %eax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3490
movq %rax, -0x90(%rbp)
jmp 0x3114f
movq -0x90(%rbp), %rax
movb (%rax), %al
movb %al, -0x59(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x3119b
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1a5f0
movq %rax, -0x98(%rbp)
jmp 0x31178
movq -0x98(%rbp), %rax
movb $0x0, (%rax)
jmp 0x3119b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x34a8
jmp 0x31207
movsbl -0x59(%rbp), %eax
cmpl $0x31, %eax
jne 0x311e2
movb -0x58(%rbp), %al
movb $0x7, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xa4(%rbp)
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1a5f0
movq %rax, -0xa0(%rbp)
jmp 0x311ce
movq -0xa0(%rbp), %rax
movl -0xa4(%rbp), %edx
movzbl (%rax), %ecx
orl %edx, %ecx
movb %cl, (%rax)
jmp 0x311e4
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x310f4
leaq -0x30(%rbp), %rdi
callq 0x34a8
addq $0xb0, %rsp
popq %rbp
retq
jmp 0x31209
movq -0x38(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0xc6266(%rip), %rdi     # 0xf7fd8
leaq 0x81653(%rip), %rsi     # 0xb33cc
callq 0x3230
movq %rax, %rdi
movq 0xc6238(%rip), %rsi     # 0xf7fc0
callq 0x3280
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xaaae0
movq -0x60(%rbp), %rdi
movq $0xc0, -0x30(%rbp)
movq $0xc0, -0x38(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x6, -0x8(%rbp)
movl $0x8, -0x4(%rbp)
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rax
imulq %rax, %rsi
shlq $0x2, %rsi
xorl %edx, %edx
callq 0x1a540
jmp 0x31de1
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x31f3e
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x31f2b
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdx
movq %rax, %rsi
andq %rdx, %rsi
xorl %ecx, %ecx
subq $0x1, %rsi
sbbl %ecx, %ecx
movb %cl, -0x69(%rbp)
movq -0x30(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rax
leaq (%rax,%rcx,4), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x68(%rbp)
jmp 0x31e45
movq -0x68(%rbp), %rax
movb -0x69(%rbp), %cl
movb %cl, (%rax)
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdx
movl %edx, %esi
movl %eax, %ecx
xorl %esi, %ecx
movb %cl, -0x79(%rbp)
movq -0x30(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rax
leaq 0x1(%rax,%rcx,4), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x78(%rbp)
jmp 0x31e7f
movq -0x78(%rbp), %rax
movb -0x79(%rbp), %cl
movb %cl, (%rax)
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdx
movl %edx, %esi
movl %eax, %ecx
orl %esi, %ecx
movb %cl, -0x89(%rbp)
movq -0x30(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x2, %rax
leaq 0x2(%rax,%rcx,4), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x88(%rbp)
jmp 0x31ebf
movq -0x88(%rbp), %rax
movb -0x89(%rbp), %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %rax
imulq %rax, %rcx
movq -0x58(%rbp), %rax
shlq $0x2, %rax
leaq 0x3(%rax,%rcx,4), %rsi
leaq -0x28(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x98(%rbp)
jmp 0x31ef9
movq -0x98(%rbp), %rax
movb $-0x1, (%rax)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x31dff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xaab00
jmp 0x31f5b
jmp 0x31f2d
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x31de9
leaq -0x28(%rbp), %rdi
callq 0x30ea0
jmp 0x31f49
leaq -0x28(%rbp), %rdi
callq 0xaab00
addq $0xa0, %rsp
popq %rbp
retq
jmp 0x31f5d
movq -0x40(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nop
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq 0xc604a(%rip), %rdi     # 0xf7fd8
leaq 0x8144d(%rip), %rsi     # 0xb33e2
callq 0x3230
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x3420
movq %rax, %rdi
leaq 0x82554(%rip), %rsi     # 0xb4503
movq %rsi, -0x58(%rbp)
callq 0x3230
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x3420
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3420
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x3230
movq %rax, %rdi
movl -0x10(%rbp), %esi
callq 0x3420
movq %rax, %rdi
movq 0xc5fc5(%rip), %rsi     # 0xf7fc0
callq 0x3280
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xaaae0
movq -0x50(%rbp), %rdi
movl $0x1, -0x20(%rbp)
movl $0x1, -0x1c(%rbp)
movl $0x6, -0x18(%rbp)
movl $0x8, -0x14(%rbp)
movl $0x4, %esi
xorl %edx, %edx
callq 0x1a540
jmp 0x3203b
movb -0x4(%rbp), %al
movb %al, -0x61(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x60(%rbp)
jmp 0x32054
movq -0x60(%rbp), %rax
movb -0x61(%rbp), %cl
movb %cl, (%rax)
movb -0x8(%rbp), %al
movb %al, -0x71(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x1a5f0
movq %rax, -0x70(%rbp)
jmp 0x32077
movq -0x70(%rbp), %rax
movb -0x71(%rbp), %cl
movb %cl, (%rax)
movb -0xc(%rbp), %al
movb %al, -0x81(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x1a5f0
movq %rax, -0x80(%rbp)
jmp 0x3209d
movq -0x80(%rbp), %rax
movb -0x81(%rbp), %cl
movb %cl, (%rax)
movb -0x10(%rbp), %al
movb %al, -0x91(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x3, %esi
callq 0x1a5f0
movq %rax, -0x90(%rbp)
jmp 0x320c9
movq -0x90(%rbp), %rax
movb -0x91(%rbp), %cl
movb %cl, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x30ea0
jmp 0x320e3
leaq -0x38(%rbp), %rdi
callq 0xaab00
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xaab00
jmp 0x3210c
jmp 0x3210e
movq -0x40(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nop
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq 0xc5130(%rip), %rdi     # 0xf7fd8
leaq 0x80570(%rip), %rsi     # 0xb341f
callq 0x3230
movq %rax, %rdi
movl -0x4(%rbp), %esi
callq 0x3310
movq %rax, %rdi
leaq 0x8163a(%rip), %rsi     # 0xb4503
callq 0x3230
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x3310
movq %rax, %rdi
movq 0xc50dd(%rip), %rsi     # 0xf7fc0
callq 0x3280
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xaaae0
movq -0x58(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x6, -0x10(%rbp)
movl $0x8, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull %ecx, %eax
shll $0x2, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1a540
jmp 0x32f2a
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl -0x8(%rbp), %ecx
cmpq %rcx, %rax
jae 0x3305c
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl -0x4(%rbp), %ecx
cmpq %rcx, %rax
jae 0x33049
movq -0x50(%rbp), %rcx
movb %cl, %al
movb %al, -0x61(%rbp)
movl -0x4(%rbp), %eax
shll $0x2, %eax
movq -0x48(%rbp), %rdx
imulq %rdx, %rax
leaq (%rax,%rcx,4), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x60(%rbp)
jmp 0x32f84
movq -0x60(%rbp), %rax
movb -0x61(%rbp), %cl
movb %cl, (%rax)
movq -0x48(%rbp), %rcx
movb %cl, %al
movb %al, -0x71(%rbp)
movl -0x4(%rbp), %eax
shll $0x2, %eax
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
leaq 0x1(%rax,%rcx,4), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x70(%rbp)
jmp 0x32fb8
movq -0x70(%rbp), %rax
movb -0x71(%rbp), %cl
movb %cl, (%rax)
movl -0x4(%rbp), %eax
shll $0x2, %eax
movq -0x48(%rbp), %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
leaq 0x2(%rax,%rcx,4), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x80(%rbp)
jmp 0x32fe7
movq -0x80(%rbp), %rax
movb $-0x1, (%rax)
movl -0x4(%rbp), %eax
shll $0x2, %eax
movq -0x48(%rbp), %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
leaq 0x3(%rax,%rcx,4), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x88(%rbp)
jmp 0x33017
movq -0x88(%rbp), %rax
movb $-0x1, (%rax)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x32f4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xaab00
jmp 0x33079
jmp 0x3304b
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x32f32
leaq -0x30(%rbp), %rdi
callq 0x30ea0
jmp 0x33067
leaq -0x30(%rbp), %rdi
callq 0xaab00
addq $0x90, %rsp
popq %rbp
retq
jmp 0x3307b
movq -0x38(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq 0xc00f2(%rip), %rdi     # 0xf7fd8
leaq 0x7bcf4(%rip), %rsi     # 0xb3be1
callq 0x3230
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3200
movq %rax, %rdi
movq 0xc00b8(%rip), %rsi     # 0xf7fc0
callq 0x3280
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1a4a0
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x115b0
jmp 0x37f29
leaq -0x50(%rbp), %rdi
callq 0x3350
jmp 0x37f34
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1a400
movq %rax, -0x68(%rbp)
jmp 0x37f53
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
cmpq %rcx, %rax
jae 0x37fba
movq -0x58(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x78(%rbp)
jmp 0x37f73
movq -0x78(%rbp), %rax
movsbl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x3170
jmp 0x37f85
jmp 0x37f87
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x37f3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x37fe6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x34a8
jmp 0x37fe4
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
callq 0x364a0
jmp 0x37fc7
leaq -0x50(%rbp), %rdi
callq 0x34a8
jmp 0x37fd2
leaq -0x20(%rbp), %rdi
callq 0x1a4c0
addq $0x80, %rsp
popq %rbp
retq
jmp 0x37fe6
leaq -0x20(%rbp), %rdi
callq 0x1a4c0
jmp 0x37ff1
jmp 0x37ff3
movq -0x28(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xaabe0
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0xaac00
movl %eax, -0x1b4(%rbp)
jmp 0x3848f
movl -0x1b4(%rbp), %edx
movq -0x1c0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x33b0
jmp 0x384aa
jmp 0x384ac
leaq -0x1a0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x3040
movq %rax, -0x1d8(%rbp)
jmp 0x384c8
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3390
movq %rax, -0x1e0(%rbp)
jmp 0x384e7
movq -0x1e0(%rbp), %rax
cmpq $0x0, %rax
je 0x3853f
movq -0x1d0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xaac20
jmp 0x38509
jmp 0x384ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x38577
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31b0
jmp 0x38559
movb $0x1, -0x11(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31b0
jmp 0x38551
testb $0x1, -0x11(%rbp)
jne 0x38567
jmp 0x3855b
jmp 0x38577
movq -0x1d0(%rbp), %rdi
callq 0xaac90
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0xaac90
jmp 0x38585
jmp 0x38587
movq -0x1a8(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x9272a(%rip), %eax     # 0xdbe68
movl %eax, -0x4(%rbp)
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x47cd0
movq 0x698e5(%rip), %rax     # 0xb3040
movq %rax, -0xc(%rbp)
leaq -0xc(%rbp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x47cd0
movq 0x6986b(%rip), %rax     # 0xb2fe4
movq %rax, -0x18(%rbp)
movl 0x69869(%rip), %eax     # 0xb2fec
movl %eax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x3, %esi
movl $0x3, %edx
callq 0x47cd0
leaq -0x30(%rbp), %rdi
callq 0x1a4a0
movl $0x0, -0x34(%rbp)
cmpl $0x100, -0x34(%rbp)     # imm = 0x100
jge 0x49827
movb -0x34(%rbp), %al
movb %al, -0x35(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x35(%rbp), %rsi
callq 0x23860
jmp 0x497c7
movb $0x5, -0x45(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x45(%rbp), %rsi
callq 0x23860
jmp 0x497da
movb $0x6, -0x46(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x46(%rbp), %rsi
callq 0x23860
jmp 0x497ed
movb $-0x80, -0x47(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x47(%rbp), %rsi
callq 0x23860
jmp 0x49800
jmp 0x49802
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x497a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1a4c0
jmp 0x498d2
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x58(%rbp)
jmp 0x4983a
movq -0x58(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x3, %edx
callq 0x47cd0
jmp 0x4984f
movb $0x5, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x23860
jmp 0x49862
movb $0x6, -0x49(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x49(%rbp), %rsi
callq 0x23860
jmp 0x49875
movb $0x7, -0x4a(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x4a(%rbp), %rsi
callq 0x23860
jmp 0x49888
movb $0x8, -0x4b(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x4b(%rbp), %rsi
callq 0x23860
jmp 0x4989b
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x1a5f0
movq %rax, -0x60(%rbp)
jmp 0x498ae
movq -0x60(%rbp), %rdi
movl $0x101, %esi            # imm = 0x101
movl $0x6, %edx
callq 0x47cd0
jmp 0x498c3
leaq -0x30(%rbp), %rdi
callq 0x1a4c0
addq $0x60, %rsp
popq %rbp
retq
jmp 0x498d4
movq -0x40(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movb %cl, -0xb(%rbp)
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x9(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
leaq -0xb(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x23860
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movw %dx, -0xc(%rbp)
movw %cx, -0xe(%rbp)
movw %ax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
leaq -0x11(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x12(%rbp)
leaq -0x12(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, -0x13(%rbp)
leaq -0x13(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
leaq -0x15(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0xe(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, -0x17(%rbp)
leaq -0x17(%rbp), %rsi
callq 0x23860
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x23860
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movb 0x10(%rbp), %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x56a0
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x56a0
movl -0x18(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x70(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1bfa0
movq -0xa8(%rbp), %rcx
leaq -0x88(%rbp), %rdi
movl $0x8, %esi
movl $0xff, %edx
callq 0xab710
jmp 0x7fc43
leaq -0x89(%rbp), %rdi
callq 0x1bff0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movzbl -0x19(%rbp), %r8d
andl $0x1, %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
leaq -0x70(%rbp), %r8
movq %r8, 0x10(%rax)
leaq -0x48(%rbp), %r8
movq %r8, 0x8(%rax)
movl $0x0, 0x18(%rax)
movl $0x1, (%rax)
leaq -0x88(%rbp), %r8
movl $0x1, %r9d
callq 0x7c930
jmp 0x7fc9c
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movzbl -0x19(%rbp), %r8d
andl $0x1, %r8d
movq %rsp, %rax
movl %r8d, 0x20(%rax)
leaq -0x70(%rbp), %r8
movq %r8, 0x10(%rax)
leaq -0x48(%rbp), %r8
movq %r8, 0x8(%rax)
movl $0x1, 0x18(%rax)
movl $0x1, (%rax)
leaq -0x88(%rbp), %r8
movl $0x1, %r9d
callq 0x7c930
jmp 0x7fce9
leaq -0x88(%rbp), %rdi
callq 0x1a4c0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x1bff0
jmp 0x7fd40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1a4c0
jmp 0x7fd3e
jmp 0x7fd40
movq -0x98(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0xa9ff0
jmp 0xaa0f6
jmp 0xaa180
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30f0
movq 0x4dec1(%rip), %rdi     # 0xf7fd8
movq 0x4dea2(%rip), %rsi     # 0xf7fc0
callq 0x3280
jmp 0xaa125
movq 0x4deac(%rip), %rdi     # 0xf7fd8
leaq 0x31cae(%rip), %rsi     # 0xdbde1
callq 0x3230
movq %rax, -0x20(%rbp)
jmp 0xaa13e
movq -0x20(%rbp), %rdi
movq 0x4de77(%rip), %rsi     # 0xf7fc0
callq 0x3280
jmp 0xaa150
movq 0x4de81(%rip), %rdi     # 0xf7fd8
leaq 0x31c91(%rip), %rsi     # 0xdbdef
callq 0x3230
movq %rax, -0x28(%rbp)
jmp 0xaa169
movq -0x28(%rbp), %rdi
movq 0x4de4c(%rip), %rsi     # 0xf7fc0
callq 0x3280
jmp 0xaa17b
callq 0x33d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x33d0
jmp 0xaa19b
jmp 0xaa19d
movq -0x10(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nop
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3110
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0xab040
movb %al, -0xa9(%rbp)
jmp 0xaae61
leaq -0x38(%rbp), %rdi
callq 0x34a8
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0xaae79
jmp 0xab022
movq 0x4d158(%rip), %rdi     # 0xf7fd8
leaq 0x30fb2(%rip), %rsi     # 0xdbe39
callq 0x3230
movq %rax, -0xd8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xab070
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x3200
movq %rax, -0xc8(%rbp)
jmp 0xaaec3
movq -0xc8(%rbp), %rdi
leaq 0x82a8(%rip), %rsi      # 0xb3179
callq 0x3230
movq %rax, -0xe0(%rbp)
jmp 0xaaedf
movq -0x10(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x3110
jmp 0xaaef1
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xab070
jmp 0xaaf06
movq -0xe0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3200
movq %rax, -0xe8(%rbp)
jmp 0xaaf22
movq -0xe8(%rbp), %rdi
leaq 0x812c(%rip), %rsi      # 0xb305c
callq 0x3230
movq %rax, -0xf0(%rbp)
jmp 0xaaf3e
movq -0xf0(%rbp), %rdi
leaq 0x8113(%rip), %rsi      # 0xb305f
callq 0x3230
movq %rax, -0xf8(%rbp)
jmp 0xaaf5a
movq -0xf8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3200
movq %rax, -0x100(%rbp)
jmp 0xaaf73
movq -0x100(%rbp), %rdi
movq 0x4d03f(%rip), %rsi     # 0xf7fc0
callq 0x3280
jmp 0xaaf88
leaq -0x88(%rbp), %rdi
callq 0x34a8
jmp 0xaaf96
leaq -0xa8(%rbp), %rdi
callq 0x34a8
jmp 0xaafa4
leaq -0x68(%rbp), %rdi
callq 0x34a8
callq 0x28bd0
jmp 0xab022
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x34a8
jmp 0xaafcb
jmp 0xab02b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xab015
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xab005
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x34a8
jmp 0xab003
jmp 0xab005
leaq -0xa8(%rbp), %rdi
callq 0x34a8
jmp 0xab013
jmp 0xab015
leaq -0x68(%rbp), %rdi
callq 0x34a8
jmp 0xab020
jmp 0xab02b
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3430
movq %rax, %rdi
callq 0x1a490
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3190
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xaaa0d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x32a0
movsbl (%rax), %edi
callq 0x29070
shll $0x12, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x32a0
movsbl (%rax), %edi
callq 0x29070
movl %eax, %ecx
movl -0x34(%rbp), %eax
shll $0xc, %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x32a0
movsbl (%rax), %edi
callq 0x29070
movl %eax, %ecx
movl -0x30(%rbp), %eax
shll $0x6, %ecx
addl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x3, %rsi
callq 0x32a0
movsbl (%rax), %edi
callq 0x29070
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movb %al, -0x1d(%rbp)
leaq -0x1d(%rbp), %rsi
callq 0x23860
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
callq 0x32a0
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0xaa9c6
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x1e(%rbp)
leaq -0x1e(%rbp), %rsi
callq 0x23860
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x3, %rsi
callq 0x32a0
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0xaa9fa
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
sarl $0x0, %eax
andl $0xff, %eax
movb %al, -0x1f(%rbp)
leaq -0x1f(%rbp), %rsi
callq 0x23860
jmp 0xaa9fc
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0xaa8c8
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x6c50
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x6c80
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x6c50
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, (%rax)
jge 0x6866
movl $0x2, 0x34(%rsp)
jmp 0x68d8
movq 0x18(%rsp), %rdi
movl (%rdi), %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0x6cd0
movq 0x18(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
callq 0x6cb0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movl %eax, %edx
movl 0x24(%rsp), %ecx
callq 0x2120
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
jge 0x68bb
movl $0x2, 0x34(%rsp)
jmp 0x68d8
movq 0x18(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x68d0
movl $0x1, 0x34(%rsp)
jmp 0x68d8
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)