LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_util.cpp
// Function: lodepng::mulMatrixMatrix(float*, float const*, float const*)
static void mulMatrixMatrix(float* result, const float* a, const float* b) {
  int i;
  float temp[9]; /* temp is to allow result and a or b to be the same */
  mulMatrix(&temp[0], &temp[3], &temp[6], a, b[0], b[3], b[6]);
  mulMatrix(&temp[1], &temp[4], &temp[7], a, b[1], b[4], b[7]);
  mulMatrix(&temp[2], &temp[5], &temp[8], a, b[2], b[5], b[8]);
  for(i = 0; i < 9; i++) result[i] = temp[i];
}

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

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

  if(info->srgb_defined) return 1;

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

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

  return 1;
}

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

// Assembly:
leal -0x41(%rdi), %eax
cmpl $0x1a, %eax
jae 0x16743
retq
leal -0x61(%rdi), %eax
cmpl $0x19, %eax
ja 0x16750
addl $-0x47, %edi
jmp 0x1675b
leal -0x30(%rdi), %eax
cmpl $0x9, %eax
ja 0x1675e
addl $0x4, %edi
movl %edi, %eax
retq
xorl %eax, %eax
cmpl $0x2f, %edi
movl $0x3f, %ecx
cmovnel %eax, %ecx
cmpl $0x2b, %edi
movl $0x3e, %eax
cmovnel %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9da9b(%rip), %eax     # 0xb4218
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, 0x9da80(%rip)     # 0xb4218
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x167a0
movl (%r12), %r9d
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
movl (%r13), %r12d
movl %r12d, %esi
andl %eax, %esi
movq %rsi, 0x20(%rsp)
movl %r12d, %esi
shrl $0x8, %esi
andl %eax, %esi
movq %rsi, 0x18(%rsp)
movl %r12d, %esi
shrl $0x10, %esi
andl %eax, %esi
movq %rsi, 0x10(%rsp)
movl (%r15), %ebp
movl %ebp, %esi
andl %eax, %esi
movq %rsi, 0x8(%rsp)
movl %ebp, %r14d
shrl $0x8, %r14d
andl %eax, %r14d
movl %ebp, %ebx
shrl $0x10, %ebx
andl %eax, %ebx
leaq 0x4(%rsp), %rsi
movl (%rsi), %r15d
movl %r15d, %r10d
andl %eax, %r10d
movl %r15d, %r11d
shrl $0x8, %r11d
andl %eax, %r11d
movl %r15d, %r13d
shrl $0x10, %r13d
andl %eax, %r13d
shrl $0x18, %r9d
shrl $0x18, %r12d
shrl $0x18, %ebp
shrl $0x18, %r15d
leaq 0x5f63c(%rip), %rsi     # 0x76104
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
pushq %r15
pushq %r13
pushq %r11
pushq %r10
pushq %rbp
pushq %rbx
pushq %r14
pushq 0x40(%rsp)
pushq %r12
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
callq 0x2070
addq $0x60, %rsp
movq 0x28(%rsp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1517a
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_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
movl %esi, 0x18(%rdi)
movl %edx, 0x1c(%rdi)
movl %ecx, 0x20(%rdi)
movl %r8d, 0x24(%rdi)
xorl %eax, %eax
cmpl $0x6, %ecx
ja 0x16b8e
movl %ecx, %eax
leaq 0x885ed(%rip), %rcx     # 0x9f178
movl (%rcx,%rax,4), %eax
imull %r8d, %eax
imull %esi, %r14d
imulq %rax, %r14
leaq 0x7(%r14), %r15
shrq $0x3, %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x10b40
testq %r14, %r14
je 0x16bcf
cmpq $0x1, %r15
adcq $0x0, %r15
xorl %eax, %eax
movq (%rbx), %rcx
leal -0x80(%rax), %edx
movb %dl, (%rcx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x16bbe
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x172f6
movq %rbx, %rdi
callq 0x17f3a
movq %rbx, %rdi
callq 0x1aeca
movq %rbx, %rdi
callq 0x199eb
movq %rbx, %rdi
popq %rbx
jmp 0x19a4a
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: codecTest(unsigned int, unsigned int, LodePNGColorType, unsigned int)
void codecTest(unsigned width, unsigned height, LodePNGColorType colorType = LCT_RGBA, unsigned bitDepth = 8) {
  std::cout << "codec test " << width << " " << height << std::endl;
  Image image;
  generateTestImage(image, width, height, colorType, bitDepth);
  doCodecTest(image);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x982d9(%rip), %r12     # 0xb3fd8
leaq 0x5a6c0(%rip), %rsi     # 0x763c6
movl $0xb, %edx
movq %r12, %rdi
callq 0x2270
movl %r15d, %esi
movq %r12, %rdi
callq 0x2150
movq %rax, %r12
leaq 0x5b81d(%rip), %rsi     # 0x77545
movl $0x1, %edx
movq %rax, %rdi
callq 0x2270
movl %r14d, %esi
movq %r12, %rdi
callq 0x2150
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x16b63
movq %rsp, %rdi
callq 0x1bcb8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1bda1
callq 0x2200
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1bdbf
callq 0x2200
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1bdc7
movq 0x8(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10b40
cmpq $0x0, 0x10(%rsp)
je 0x1bea7
xorl %eax, %eax
movq %rax, %rdx
shrq $0x3, %rdx
movq %rax, %rcx
movq 0x8(%rsp), %rsi
movb (%rsi,%rax), %sil
andq $0x7, %rcx
jne 0x1be87
movq (%rbx), %rdi
movb $0x0, (%rdi,%rdx)
cmpb $0x31, %sil
jne 0x1be9d
xorb $0x7, %cl
movb $0x1, %sil
shlb %cl, %sil
movq (%rbx), %rcx
orb %sil, (%rcx,%rdx)
incq %rax
cmpq 0x10(%rsp), %rax
jb 0x1be67
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1beba
callq 0x2200
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bed8
callq 0x2200
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testSinglePixel(int, int, int, int)
void testSinglePixel(int r, int g, int b, int a) {
  std::cout << "codec single pixel " << r << " " << g << " " << b << " " << a << std::endl;
  Image pixel;
  pixel.width = 1;
  pixel.height = 1;
  pixel.colorType = LCT_RGBA;
  pixel.bitDepth = 8;
  pixel.data.resize(4);
  pixel.data[0] = r;
  pixel.data[1] = g;
  pixel.data[2] = b;
  pixel.data[3] = a;

  doCodecTest(pixel);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
movq 0x9785c(%rip), %r12     # 0xb3fd8
leaq 0x59ca7(%rip), %rsi     # 0x7642a
movl $0x13, %edx
movq %r12, %rdi
callq 0x2270
movq %r12, %rdi
movl %r15d, %esi
callq 0x2390
movq %rax, %r13
leaq 0x5ada0(%rip), %r12     # 0x77545
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2270
movq %r13, %rdi
movl %r14d, %esi
callq 0x2390
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2270
movq %r13, %rdi
movl %ebp, %esi
callq 0x2390
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2270
movq %r13, %rdi
movl %ebx, %esi
callq 0x2390
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movaps 0x59744(%rip), %xmm0    # 0x75f80
movups %xmm0, 0x18(%rdi)
movl $0x4, %esi
xorl %edx, %edx
callq 0x10b40
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 0x1bcb8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c87c
callq 0x2200
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c89c
callq 0x2200
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testSize(unsigned int, unsigned int)
void testSize(unsigned w, unsigned h) {
  std::cout << "codec test size " << w << " " << h << std::endl;
  Image image;
  image.width = w;
  image.height = h;
  image.colorType = LCT_RGBA;
  image.bitDepth = 8;
  image.data.resize(w * h * 4);
  for(size_t y = 0; y < h; y++)
  for(size_t x = 0; x < w; x++) {
    image.data[w * 4 * y + 4 * x + 0] = x & 255;
    image.data[w * 4 * y + 4 * x + 1] = y & 255;
    image.data[w * 4 * y + 4 * x + 2] = 255;
    image.data[w * 4 * y + 4 * x + 3] = 255;
  }

  doCodecTest(image);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movl %edi, %ebx
movq 0x96c9b(%rip), %r15     # 0xb3fd8
leaq 0x59123(%rip), %rsi     # 0x76467
movl $0x10, %edx
movq %r15, %rdi
callq 0x2270
movl %ebx, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2150
movq %rax, %r12
leaq 0x5a1dc(%rip), %rsi     # 0x77545
movl $0x1, %edx
movq %rax, %rdi
callq 0x2270
movl %ebp, %r15d
movq %r12, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl %ebx, 0x18(%rdi)
movl %ebp, 0x1c(%rdi)
movabsq $0x800000006, %rax      # imm = 0x800000006
movq %rax, 0x20(%rdi)
movl %ebx, %esi
imull %ebp, %esi
shll $0x2, %esi
xorl %edx, %edx
callq 0x10b40
testl %ebp, %ebp
je 0x1d439
leal (,%rbx,4), %eax
xorl %ecx, %ecx
movb $-0x1, %dl
xorl %esi, %esi
testl %ebx, %ebx
je 0x1d42e
xorl %edi, %edi
movq %rcx, %r8
movq %r14, %r9
movq (%rsp), %r10
movb %dil, (%r10,%r8)
movq (%rsp), %r10
movb %sil, 0x1(%r10,%r8)
movq (%rsp), %r10
movb %dl, 0x2(%r10,%r8)
movq (%rsp), %r10
movb %dl, 0x3(%r10,%r8)
incb %dil
addq $0x4, %r8
decq %r9
jne 0x1d3ff
incq %rsi
addq %rax, %rcx
cmpq %r15, %rsi
jne 0x1d3f3
movq %rsp, %rdi
callq 0x1bcb8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d44f
callq 0x2200
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1d46d
callq 0x2200
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testDiskCompressZlib(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void testDiskCompressZlib(const std::string& filename) {
  std::cout << "testDiskCompressZlib: File " << filename << std::endl;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x9414e(%rip), %r14     # 0xb3fd8
leaq 0x56d98(%rip), %rsi     # 0x76c29
movl $0x1b, %edx
movq %r14, %rdi
callq 0x2270
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x2270
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rbx, %rsi
callq 0xcf0c
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x1ff39
xorl %r15d, %r15d
leaq 0x20(%rsp), %rbx
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x21e0
incq %r15
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
cmpq %rcx, %r15
jb 0x1ff18
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x1eef2
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ff54
callq 0x2200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ff62
callq 0x2200
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ff73
movq %rax, %rbx
jmp 0x1ff85
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x1ff85
callq 0x2200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ff93
callq 0x2200
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: strtovector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<unsigned> strtovector(const std::string& numbers) {
  std::vector<unsigned> result;
  std::stringstream ss(numbers);
  unsigned i;
  while(ss >> i) result.push_back(i);
  return result;
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq (%rsi), %r12
movq 0x8(%rsi), %rax
movq %rax, 0x60(%rsp)
addq $0x8, %r12
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0x560d4(%rip), %rdx     # 0x77546
movq %rdi, 0x10(%rsp)
movq %rdx, %rsi
callq 0x1517a
leaq 0x28(%rsp), %r15
leaq 0x3b(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq %r13, %rdi
movq %r12, %rsi
callq 0x4e89
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x56096(%rip), %rsi     # 0x77545
leaq 0x56090(%rip), %rdx     # 0x77546
callq 0x1517a
movq %r15, 0x18(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x15390
movq %rbp, %rdi
movq %r13, %rsi
callq 0x23d0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rdi
callq 0x20c0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x21503
callq 0x2200
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x21517
callq 0x2200
movq %r15, 0x18(%rsp)
movq %r13, %rdi
callq 0x2100
leaq (%rsp,%rax), %rdx
addq $0x3b, %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1517a
movq %rbp, %rdi
leaq 0x55a3b(%rip), %rsi     # 0x76f7c
callq 0x20b0
movl %eax, %ebx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x21557
callq 0x2200
testl %ebx, %ebx
je 0x215b6
movq %r12, %rdi
movq 0x60(%rsp), %rsi
callq 0x4fe2
movq %rax, %r12
movq 0x8(%r14), %rbx
movq %r15, 0x18(%rsp)
movq %rbp, %rdi
leaq 0x55866(%rip), %rsi     # 0x76de4
leaq 0x55873(%rip), %rdx     # 0x76df8
callq 0x1517a
decq %rbx
xorl %edi, %edi
cmpq %rbx, %r12
setb %dil
movq %rbp, %rsi
callq 0x164c1
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2148e
callq 0x2200
jmp 0x2148e
movq 0x10(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21610
jmp 0x215fc
jmp 0x21610
movq %rax, %r14
jmp 0x215e9
jmp 0x215d7
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x215e9
callq 0x2200
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
jne 0x21609
jmp 0x21613
jmp 0x21610
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x21613
callq 0x2200
jmp 0x21613
movq %rax, %r14
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq %rcx, %rdi
je 0x2162a
callq 0x2200
movq %r14, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb %sil, 0xf(%rsp)
movb %dl, 0xe(%rsp)
movb %cl, 0xd(%rsp)
movb %r8b, 0xc(%rsp)
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x38a7b
movb %sil, (%rax)
incq 0x8(%rbx)
jmp 0x38a8b
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16342
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38aa1
movb 0xe(%rsp), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x38aae
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38ac4
movb 0xd(%rsp), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x38ad1
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38ae7
movb 0xc(%rsp), %al
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x38af4
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: addColor16(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned short, unsigned short, unsigned short, unsigned short)
void addColor16(std::vector<unsigned char>& colors, unsigned short r, unsigned short g, unsigned short b, unsigned short a) {
  colors.push_back(r & 255);
  colors.push_back((r >> 8) & 255);
  colors.push_back(g & 255);
  colors.push_back((g >> 8) & 255);
  colors.push_back(b & 255);
  colors.push_back((b >> 8) & 255);
  colors.push_back(a & 255);
  colors.push_back((a >> 8) & 255);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movb %r12b, 0xf(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x38b2d
movb %r12b, (%rsi)
incq 0x8(%rbx)
jmp 0x38b3a
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
shrl $0x8, %r12d
movb %r12b, 0xe(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38b56
movb %r12b, (%rsi)
incq 0x8(%rbx)
jmp 0x38b63
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
movb %r15b, 0xd(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38b7b
movb %r15b, (%rsi)
incq 0x8(%rbx)
jmp 0x38b88
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
shrl $0x8, %r15d
movb %r15b, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38ba4
movb %r15b, (%rsi)
incq 0x8(%rbx)
jmp 0x38bb1
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
movb %r14b, 0xb(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38bc9
movb %r14b, (%rsi)
incq 0x8(%rbx)
jmp 0x38bd6
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
shrl $0x8, %r14d
movb %r14b, 0xa(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38bf2
movb %r14b, (%rsi)
incq 0x8(%rbx)
jmp 0x38bff
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
movb %bpl, 0x9(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38c17
movb %bpl, (%rsi)
incq 0x8(%rbx)
jmp 0x38c24
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
shrl $0x8, %ebp
movb %bpl, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x38c3f
movb %bpl, (%rsi)
incq 0x8(%rbx)
jmp 0x38c4c
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x16342
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng_unittest.cpp
// Function: testSbitChunk(unsigned int, unsigned int, unsigned int, unsigned int, LodePNGColorType, unsigned int, bool)
void testSbitChunk(unsigned r, unsigned g, unsigned b, unsigned a,
                   LodePNGColorType type, unsigned bitdepth,
                   bool expect_encoder_error = false) {
  LodePNGColorMode mode_raw;
  lodepng_color_mode_init(&mode_raw);
  mode_raw.bitdepth = bitdepth;
  mode_raw.colortype = type;
  LodePNGColorMode mode_png;
  lodepng_color_mode_init(&mode_png);
  mode_png.bitdepth = bitdepth;
  mode_png.colortype = type;

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

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

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

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

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

  //lodepng_util
  testChunkUtil();
  testGetFilterTypes();

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

// Assembly:
pushq %rbx
callq 0x66e42
callq 0x6fc6e
callq 0x1d475
callq 0x2997e
callq 0x21632
callq 0x27c4d
callq 0x359cb
callq 0x2ed8e
callq 0x36193
callq 0x3b3f3
callq 0x3c5da
callq 0x42b9d
callq 0x4c98d
callq 0x508af
callq 0x50ec4
callq 0x55432
callq 0x1cbcd
callq 0x2bc7a
callq 0x1d725
callq 0x1e8d1
callq 0x2a001
callq 0x2ba4f
callq 0x333ed
callq 0x3a17f
callq 0x2d776
callq 0x59487
callq 0x599a7
callq 0x5afac
callq 0x60a21
callq 0x1faca
callq 0x208a4
callq 0x2f268
callq 0x2fc6f
callq 0x307d3
callq 0x311db
callq 0x31e4d
callq 0x32abf
callq 0x19aa9
movq 0x441ad(%rip), %rbx     # 0xb3fd8
leaq 0x2efe0(%rip), %rsi     # 0x9ee12
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2270
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6fd65
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rdi
callq 0x20f0
movq 0x44158(%rip), %rdi     # 0xb3fd8
callq 0x2110
movq 0x4414c(%rip), %rdi     # 0xb3fd8
leaq 0x2ef90(%rip), %rsi     # 0x9ee23
movl $0xd, %edx
callq 0x2270
movq 0x44134(%rip), %rdi     # 0xb3fd8
callq 0x2110
movq 0x44128(%rip), %rdi     # 0xb3fd8
leaq 0x2ef7a(%rip), %rsi     # 0x9ee31
movl $0x13, %edx
callq 0x2270
movq 0x44110(%rip), %rdi     # 0xb3fd8
callq 0x2110
callq 0x2340
jmp 0x6fe6d
movq %rax, %rbx
callq 0x2340
movq %rbx, %rdi
callq 0x23b0
movq %rax, %rdi
callq 0x14f59
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x2, %ebx
testl %edi, %edi
js 0x34e0
movl %esi, %ecx
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %edx # imm = 0xAAAAAAAB
callq 0x2110
movl %eax, 0x20(%r14)
testl %eax, %eax
js 0x34e0
sete %al
movzbl %al, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl %esi, 0x20(%rdi)
jbe 0x3523
movl %esi, %ecx
movq 0x8(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %edx
testb $0x8, %dl
jne 0x3512
testb $0x11, %dl
je 0x353e
movabsq $0x100000000, %rdx      # imm = 0x100000000
jmp 0x351c
movabsq $0x300000000, %rdx      # imm = 0x300000000
xorl %esi, %esi
testb %sil, %sil
je 0x3534
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movabsq $0x400000000, %rdx      # imm = 0x400000000
jmp 0x3538
movl 0x4(%rax,%rcx,4), %eax
movl %eax, %eax
orq %rdx, %rax
retq
testb $0x4, %dl
sete %sil
movabsq $0x200000000, %rdx      # imm = 0x200000000
jmp 0x351e
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/net/selector/epollselector.cc
// Function: net::selector::EPollSelector::mutateFD_(int, net::selector::FDEvent, int)
bool EPollSelector::mutateFD_(int const fd, FDEvent const event, int const op){
	epoll_event ev;
	ev.events = epollConvert(event);
	ev.data.fd = fd;

	int const result = epoll_ctl(epollFD_, op, fd, &ev);

	return result >= 0;
}

// Assembly:
subq $0x18, %rsp
movl %esi, %eax
xorl %esi, %esi
cmpl $0x1, %edx
sete %sil
leal (%rsi,%rsi,2), %edx
incl %edx
leaq 0xc(%rsp), %r8
movl %edx, (%r8)
movl %eax, 0x4(%r8)
movl (%rdi), %edi
movl %ecx, %esi
movl %eax, %edx
movq %r8, %rcx
callq 0x21d0
testl %eax, %eax
setns %al
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/../include/util/dimacs.hpp
// Function: (anonymous namespace)::UnitParser::parse_integer()
int parse_integer(void) {
        int value = 0;
        bool neg = false;
        skip_whitespace();

        if (_current_line[_pos] == '-') {
            neg = true;
            _pos++;
        } else if (_current_line[_pos] == '+') {
            _pos++;
        }

        if (_current_line[_pos] < '0' || _current_line[_pos] > '9') {
            fprintf(stderr, "PARSE ERROR! Unexpected char: %c\n", _current_line[_pos]);
            std::exit(3);
        }

        for (; _current_line[_pos] >= '0' && _current_line[_pos] <= '9'; _pos++) {
            value = value * 10 + (_current_line[_pos] - '0');
        }

        return neg ? -value : value;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movslq 0x10(%rdi), %rcx
leal 0x1(%rcx), %edx
addq %rax, %rcx
movzbl (%rcx), %esi
leal -0x9(%rsi), %r8d
cmpl $0x5, %r8d
jae 0x27e3
movl %edx, 0x10(%rdi)
incl %edx
incq %rcx
jmp 0x27cc
cmpl $0x20, %esi
je 0x27d9
movslq 0x10(%rdi), %rdx
movzbl (%rax,%rdx), %ecx
cmpl $0x2d, %ecx
je 0x27fa
cmpl $0x2b, %ecx
jne 0x27ff
incl %edx
movl %edx, 0x10(%rdi)
movslq 0x10(%rdi), %rdx
movb (%rax,%rdx), %dl
leal -0x3a(%rdx), %esi
cmpb $-0xa, %sil
jb 0x285c
movslq 0x10(%rdi), %r8
movb (%rax,%r8), %dl
leal -0x30(%rdx), %r9d
xorl %esi, %esi
cmpb $0x9, %r9b
ja 0x2850
addq %r8, %rax
incq %rax
incl %r8d
xorl %esi, %esi
leal (%rsi,%rsi,4), %esi
addb $-0x30, %dl
movzbl %dl, %edx
leal (%rdx,%rsi,2), %esi
movl %r8d, 0x10(%rdi)
movb (%rax), %dl
leal -0x30(%rdx), %r9d
incq %rax
incl %r8d
cmpb $0xa, %r9b
jb 0x282e
movl %esi, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %esi, %eax
popq %rbp
retq
movzbl %dl, %edi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::new_variable(MyyuraSat::LiftedBoolean, bool)
Variable Solver::new_variable(LiftedBoolean upol, bool dvar) {
    Variable v = _next_variable++;
    
    _watches.init(Literal(v, false));
    _watches.init(Literal(v, true));
    _occur_lit.init(Literal(v, false));
    _occur_lit.init(Literal(v, true));
    _touched.insert(v, true);
    _touched_list.push(v);
    _assigns.insert(v, LIFTED_BOOLEAN_UNDEF);
    _variable_info.insert(v, _VariableInfo(CRAREF_UNDEF, 0));
    _polarity.insert(v, false);
    _seen.insert(v, 0);
    _trail.reserve(v + 1);

    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xf0(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xf0(%rdi)
leaq -0x30(%rbp), %r14
movl %eax, (%r14)
leaq 0x88(%rdi), %r15
addl %eax, %eax
leaq -0x2c(%rbp), %r12
movl %eax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x604c
movl (%r14), %eax
leal 0x1(,%rax,2), %eax
movl %eax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x604c
leaq 0x1a0(%rbx), %r15
movl (%r14), %eax
addl %eax, %eax
movl %eax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x60a0
movl (%r14), %eax
leal 0x1(,%rax,2), %eax
movl %eax, (%r12)
leaq -0x2c(%rbp), %rsi
movq %r15, %rdi
callq 0x60a0
leaq 0x200(%rbx), %r15
movl (%r14), %r12d
leal 0x1(%r12), %esi
movq %r15, %rdi
callq 0x7904
movq %r15, %rdi
movl %r12d, %esi
callq 0x6346
movb $0x1, (%rax)
leaq 0x218(%rbx), %rdi
movq %r14, %rsi
callq 0x60f4
leaq 0x58(%rbx), %r15
movl (%r14), %r12d
movb 0xa83f(%rip), %r13b     # 0xd176
leal 0x1(%r12), %esi
movq %r15, %rdi
callq 0x79c4
movq %r15, %rdi
movl %r12d, %esi
callq 0x6282
movb %r13b, (%rax)
leaq 0x70(%rbx), %rdi
movl (%r14), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x612c
leaq 0x170(%rbx), %r15
movl (%r14), %r12d
leal 0x1(%r12), %esi
movq %r15, %rdi
callq 0x7904
movq %r15, %rdi
movl %r12d, %esi
callq 0x6346
xorl %r13d, %r13d
movb %r13b, (%rax)
leaq 0x298(%rbx), %r15
movl (%r14), %r12d
leal 0x1(%r12), %esi
movq %r15, %rdi
callq 0x7b04
movq %r15, %rdi
movl %r12d, %esi
callq 0x6496
movb %r13b, (%rax)
addq $0x28, %rbx
movl (%r14), %esi
incl %esi
movq %rbx, %rdi
callq 0x6170
movl (%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::unchecked_enqueue(MyyuraSat::Literal, unsigned int)
void Solver::unchecked_enqueue(Literal p, CRARef from) {
    // for (Variable i = 0; i < n_variables(); i++) {
    //     printf("decision level:%d | %d:%d\n", decision_level(), i, value(i).to_int());
    // }
    // printf("enqueue %d %d:%d %d\n", p.to_int(), p.variable(), value(p).to_int(), value(p.variable()).to_int()); 
    if (value(p) != LIFTED_BOOLEAN_UNDEF) {
        throw std::logic_error("Solver::unchecked_enqueue : p has already get an assignment!");
    }

    _assigns[p.variable()] = LiftedBoolean(!p.sign());
    _variable_info[p.variable()] = _VariableInfo(from, decision_level());
    _trail.push_lazy(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
leaq 0x58(%rdi), %r15
sarl %esi
movq %r15, %rdi
callq 0x6c82
movb (%rax), %al
andb $0x1, %r12b
xorb %al, %r12b
movb 0xa4f7(%rip), %cl       # 0xd176
movl %ecx, %edx
andb $0x2, %dl
andb %dl, %al
xorl %esi, %esi
testb %dl, %dl
sete %sil
xorl %edx, %edx
cmpb %cl, %r12b
cmovnel %edx, %esi
orb %al, %sil
je 0x2cf5
leaq -0x2c(%rbp), %r12
movl (%r12), %esi
movl %esi, %r13d
andb $0x1, %r13b
sarl %esi
movq %r15, %rdi
callq 0x6282
movb %r13b, (%rax)
leaq 0x70(%rbx), %rdi
movl (%r12), %esi
sarl %esi
movl 0x40(%rbx), %r15d
callq 0x5dce
shlq $0x20, %r15
movl %r14d, %ecx
orq %r15, %rcx
movq %rcx, (%rax)
addq $0x28, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x62de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x63d9(%rip), %rsi      # 0x90e2
movq %rax, %rdi
callq 0x21d0
movq 0xa2c0(%rip), %rsi      # 0xcfd8
movq 0xa271(%rip), %rdx      # 0xcf90
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::is_subsumed(unsigned int)
bool Solver::is_subsumed(CRARef cr) {
    Clause& c = _ca[cr];

    for (int i = 0; i < c.size(); i++) {
        Vector<CRARef>& crs = _occur_lit[c[i]];
        for (int j = 0; j < crs.size(); j++) {
            if (is_removed(crs[j])) { continue; }

            Clause& cp = _ca[crs[j]];
            if (cr != crs[i] && cp.subsumes(c) == LITERAL_UNDEF) {
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xf8(%rdi), %r15
movq %r15, %rdi
callq 0x6a4e
cmpl $0x20, (%rax)
setae %cl
jb 0x318f
addq $0x1a0, %r14            # imm = 0x1A0
xorl %r13d, %r13d
movq %r14, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movb %cl, -0x29(%rbp)
movl 0x4(%rax,%r13,4), %esi
movq %r14, %rdi
callq 0x7580
cmpl $0x0, 0x8(%rax)
jle 0x316e
movq %rax, %r14
xorl %r12d, %r12d
movq (%r14), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x6bc0
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x1, %eax
je 0x3162
movq (%r14), %rax
movl (%rax,%r12,4), %esi
movq %r15, %rdi
callq 0x6a4e
movq (%r14), %rcx
cmpl %ebx, (%rcx,%r13,4)
je 0x3162
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x64f2
cmpl 0xa00c(%rip), %eax      # 0xd16c
je 0x318c
incq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jl 0x311d
incq %r13
movq -0x38(%rbp), %rax
movl (%rax), %ecx
shrl $0x5, %ecx
cmpq %rcx, %r13
setb %cl
movq -0x40(%rbp), %r14
jb 0x3101
jmp 0x318f
movb -0x29(%rbp), %cl
andb $0x1, %cl
movl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::attach_clause_watcher(unsigned int)
void Solver::attach_clause_watcher(CRARef cr) {
    const Clause& c = _ca[cr];

    _watches[~c[0]].push(_Watcher(cr, c[1]));
    _watches[~c[1]].push(_Watcher(cr, c[0]));

    // for (int i = 0; i < c.size(); i++) {
    //     _watches[~c[i]].push(_Watcher(cr));
    // }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0xf8, %rdi
callq 0x6a4e
movq %rax, %r15
addq $0x88, %r14
movl 0x4(%rax), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x746e
movl 0x8(%r15), %ecx
leaq -0x28(%rbp), %r12
movl %ebx, (%r12)
movl %ecx, 0x4(%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0x61f4
movl 0x8(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x746e
movl 0x4(%r15), %ecx
movl %ebx, (%r12)
movl %ecx, 0x4(%r12)
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x61f4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_simplify.cpp
// Function: MyyuraSat::Solver::attach_clause_occlit(unsigned int, unsigned int)
void Solver::attach_clause_occlit(CRARef cr, CRARef overwrite) {
    Clause& c = _ca[cr];
    // Clause c should not be a learnt clause!

    for (int i = 0; i < c.size(); i++) {
        _occur_lit[c[i]].push(cr);
        touch(c[i]);
        if (overwrite == CRAREF_UNDEF) {
            _added.insert(cr);
        } else {
            _strengthened.insert(cr);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdi, %rbx
addq $0xf8, %rdi
callq 0x6a4e
cmpl $0x20, (%rax)
jb 0x3314
movq %rax, %r15
movq %rbx, %rax
leaq 0x1a0(%rbx), %rcx
movq %rcx, -0x50(%rbp)
leaq 0x200(%rbx), %r13
leaq 0x218(%rbx), %rcx
movq %rcx, -0x48(%rbp)
addq $0x260, %rbx            # imm = 0x260
addq $0x228, %rax            # imm = 0x228
movq %rax, -0x40(%rbp)
xorl %r12d, %r12d
leaq -0x38(%rbp), %r14
movl 0x4(%r15,%r12,4), %esi
movq -0x50(%rbp), %rdi
callq 0x7580
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c7a
movl 0x4(%r15,%r12,4), %esi
sarl %esi
movl %esi, -0x30(%rbp)
movq %r13, %rdi
callq 0x6346
cmpb $0x0, (%rax)
jne 0x32e3
movl -0x30(%rbp), %esi
movq %r13, %rdi
callq 0x6346
movb $0x1, (%rax)
movq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x60f4
cmpl $-0x1, -0x34(%rbp)
je 0x32f2
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
jmp 0x32fa
movq -0x40(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %r14, %rsi
leaq -0x30(%rbp), %rdx
callq 0x7ca0
incq %r12
movl (%r15), %eax
shrl $0x5, %eax
cmpq %rax, %r12
jb 0x3298
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::remove_clause(unsigned int)
void Solver::remove_clause(CRARef cr) {
    Clause& c = _ca[cr];
    detach_clause_watcher(cr);

    c.mark(1);
    _ca.free(cr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xf8(%rdi), %r15
movq %r15, %rdi
callq 0x6a4e
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x3388
movl (%r12), %eax
andl $-0x4, %eax
incl %eax
movl %eax, (%r12)
movq %r15, %rdi
movl %r14d, %esi
callq 0x6a4e
movl (%rax), %eax
movl %eax, %ecx
shrl $0x5, %ecx
incl %ecx
btl $0x3, %eax
adcl %ecx, 0x108(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_search.cpp
// Function: MyyuraSat::Solver::detach_clause_watcher(unsigned int, bool)
void Solver::detach_clause_watcher(CRARef cr, bool strict) {
    const Clause& c = _ca[cr];

    // strict or lazy detaching
    if (strict) {
        remove(_watches[~c[0]], _Watcher(cr, c[1]));
        remove(_watches[~c[1]], _Watcher(cr, c[0]));
    } else {
        _watches.smudge(~c[0]);
        _watches.smudge(~c[1]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r12d
movl %esi, %ebx
movq %rdi, %r14
addq $0xf8, %rdi
callq 0x6a4e
movq %rax, %r15
addq $0x88, %r14
testl %r12d, %r12d
je 0x33e6
movl 0x4(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x746e
movl 0x8(%rax), %edx
testl %edx, %edx
jle 0x341d
movq (%rax), %rsi
xorl %ecx, %ecx
cmpl %ebx, (%rsi,%rcx,8)
je 0x341f
incq %rcx
cmpq %rcx, %rdx
jne 0x33d5
movl %edx, %ecx
jmp 0x341f
movl 0x4(%r15), %eax
xorl $0x1, %eax
leaq -0x28(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x622e
movl 0x8(%r15), %eax
xorl $0x1, %eax
leaq -0x24(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x622e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
decl %edx
cmpl %edx, %ecx
jge 0x3444
movl %ecx, %edx
incq %rdx
movq (%rax), %rsi
movq (%rsi,%rdx,8), %rdi
movq %rdi, -0x8(%rsi,%rdx,8)
movl 0x8(%rax), %esi
decl %esi
incq %rdx
incl %ecx
cmpl %ecx, %esi
jg 0x342a
movq %rax, %rdi
callq 0x7c42
movl 0x8(%r15), %esi
xorl $0x1, %esi
movq %r14, %rdi
callq 0x746e
movl 0x8(%rax), %edx
testl %edx, %edx
jle 0x3478
movq (%rax), %rsi
xorl %ecx, %ecx
cmpl %ebx, (%rsi,%rcx,8)
je 0x347a
incq %rcx
cmpq %rcx, %rdx
jne 0x3467
movl %edx, %ecx
jmp 0x347a
xorl %ecx, %ecx
decl %edx
cmpl %edx, %ecx
jge 0x349f
movl %ecx, %edx
incq %rdx
movq (%rax), %rsi
movq (%rsi,%rdx,8), %rdi
movq %rdi, -0x8(%rsi,%rdx,8)
movl 0x8(%rax), %esi
decl %esi
incq %rdx
incl %ecx
cmpl %ecx, %esi
jg 0x3485
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7c42
nop
// File: /workspace/github_cpp_makefile_star2_O1/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::garbage_collect()
void Solver::garbage_collect(void) {
    /**
     * Initialize the next region to a size corresponding to the estimated 
     * utilization degree. This is not precise but should avoid some unnecessary 
     * reallocations for the new region:
     */
    ClauseAllocator to(_ca.size() - _ca.wasted());

    reloc_all(to);
    to.move_to(_ca);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x100(%rdi), %esi
subl 0x108(%rdi), %esi
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x68f0
movb $0x1, 0x18(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34b4
movb -0x18(%rbp), %al
movb %al, 0x110(%rbx)
movq 0xf8(%rbx), %rdi
testq %rdi, %rdi
je 0x3945
callq 0x2180
movq -0x30(%rbp), %rax
movq %rax, 0xf8(%rbx)
movl -0x28(%rbp), %eax
movl %eax, 0x100(%rbx)
movl -0x24(%rbp), %eax
movl %eax, 0x104(%rbx)
movl -0x20(%rbp), %eax
movl %eax, 0x108(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x3985
callq 0x2180
movq %rbx, %rdi
callq 0x2270
nop