LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/shirat74[P]resample/Resampler.cc
// Function: Resampler::Resampler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Resampler::Resampler (const std::string& filter)
{
  filter_fn = filters[0].func;
  support   = filters[0].support;
  for (int i = 0; i < NUM_FILTERS; i++) {
    if (filter == filters[i].name) {
      filter_fn = filters[i].func;
      support   = filters[i].support;
      break;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
leaq -0x367(%rip), %rax      # 0x371c
movq %rax, (%rdi)
movl $0x3f000000, 0x8(%rdi)  # imm = 0x3F000000
xorl %esi, %esi
leaq 0x51ca(%rip), %r15      # 0x8c60
leaq 0x30(%rsi), %r12
cmpq $0x150, %r12            # imm = 0x150
je 0x3ac9
addq %r15, %rsi
movq %r14, %rdi
callq 0x4213
movq %r12, %rsi
testb %al, %al
je 0x3a96
movq -0x10(%r12,%r15), %rax
movq %rax, (%rbx)
movss -0x8(%r12,%r15), %xmm0
movss %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shirat74[P]resample/Resampler.cc
// Function: Resampler::setupContributorForUpsample(float, int, int)
void
Resampler::setupContributorForUpsample (float   scale,
                                        int32_t dstSize,
                                        int32_t boundary)
{
  contributor.resize(dstSize);

  for (int32_t i = 0; i < dstSize; i++) {
    contributor[i].n = 0;
    std::vector<Contrib> p((int)(support * 2 + 1));
    contributor[i].p = p;
    float center = (float) i / scale;
    float left   = ceil (center - support);
    float right  = floor(center + support);
    for (int32_t j = left; j <= right; j++) {
      float   weight = (*filter_fn)(center - j);
      int32_t n = j;
      // reflect at boundary
      if (j < 0) {
        n = -j;
      } else if (j >= boundary) {
        n = (boundary - j) + boundary - 1;
      }
      int k = contributor[i].n++;
      contributor[i].p[k].pixel  = n;
      contributor[i].p[k].weight = weight;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movss %xmm0, 0x10(%rsp)
movq %rdi, %r14
addq $0x10, %rdi
movslq %esi, %r15
movq %rdi, 0x28(%rsp)
movq %r15, %rsi
callq 0x4220
xorl %r13d, %r13d
testl %r15d, %r15d
cmovlel %r13d, %r15d
movq %r15, 0x18(%rsp)
movq %rbx, %r15
leal -0x1(,%rbx,2), %r12d
leaq 0x30(%rsp), %rbx
cmpq 0x18(%rsp), %r13
je 0x3e23
movq 0x10(%r14), %rax
movq %r13, %rbp
shlq $0x5, %rbp
andl $0x0, (%rax,%rbp)
movss 0x8(%r14), %xmm0
addss %xmm0, %xmm0
addss 0x23d8(%rip), %xmm0     # 0x6110
cvttss2si %xmm0, %eax
movslq %eax, %rsi
movq %rbx, %rdi
leaq 0xb(%rsp), %rdx
callq 0x4250
movq 0x10(%r14), %rax
leaq (%rax,%rbp), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x42a2
movq %r13, 0x20(%rsp)
cvtsi2ss %r13d, %xmm0
divss 0x10(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x8(%r14), %xmm2
movss %xmm2, 0x4(%rsp)
subss %xmm2, %xmm0
callq 0x21c0
movss %xmm0, 0x14(%rsp)
movss 0x4(%rsp), %xmm0
addss 0xc(%rsp), %xmm0
callq 0x2100
movss %xmm0, 0x4(%rsp)
cvttss2si 0x14(%rsp), %r13d
movl %r13d, %ebx
negl %ebx
cvtsi2ss %r13d, %xmm1
movss 0x4(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x3e09
movss 0xc(%rsp), %xmm0
subss %xmm1, %xmm0
callq *(%r14)
leal (%r12,%rbx), %eax
cmpl %r15d, %r13d
cmovll %r13d, %eax
testl %r13d, %r13d
cmovsl %ebx, %eax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movslq (%rcx,%rbp), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%rbp)
movq 0x8(%rcx,%rbp), %rcx
movl %eax, (%rcx,%rdx,8)
movss %xmm0, 0x4(%rcx,%rdx,8)
incl %r13d
decl %ebx
jmp 0x3db4
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x4624
movq 0x20(%rsp), %r13
incq %r13
jmp 0x3d0c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e34
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4624
movq %rbx, %rdi
callq 0x2420
nop
// File: /workspace/github_cpp_makefile_star2_O2/shirat74[P]resample/Resampler.cc
// Function: Resampler::resampleX(Image&, Image const&) const
void
Resampler::resampleX (Image& dst, const Image& src) const
{
  for (int32_t k = 0; k < dst.getHeight(); k++) {
    for (int32_t i = 0; i < dst.getWidth(); i++) {
      Color pixel;
      for (int c = 0; c < src.getNComps(); c++) {
        float weight = 0.0;
        for (int j = 0; j < contributor[i].n; j++) {
          weight +=
            src.getPixel(contributor[i].p[j].pixel, k).v[c] *
                                        contributor[i].p[j].weight;
        }
        pixel.v[c] = (uint16_t) MAP_IN_RANGE(weight, 0, 65535u);
      }
      dst.putPixel(i, k, pixel);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq %rsi, 0x18(%rsp)
cmpl 0x4(%r14), %r12d
jge 0x3f60
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x3f58
movq %r13, 0x20(%rsp)
movq %r13, %rbp
shlq $0x5, %rbp
xorl %r14d, %r14d
movsbq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x3f2e
movq 0x10(%r15), %rax
xorps %xmm1, %xmm1
xorl %r13d, %r13d
movslq (%rax,%rbp), %rcx
cmpq %rcx, %r13
jge 0x3f08
addq %rbp, %rax
movq 0x8(%rax), %rax
movl (%rax,%r13,8), %esi
movq %rbx, %rdi
movl %r12d, %edx
movss %xmm1, 0x4(%rsp)
callq 0x2900
movss 0x4(%rsp), %xmm1
movq %rax, 0x8(%rsp)
movw %dx, 0x10(%rsp)
shrl $0x10, %edx
movb %dl, 0x12(%rsp)
movzwl 0x8(%rsp,%r14,2), %eax
cvtsi2ss %eax, %xmm0
movq 0x10(%r15), %rax
movq 0x8(%rax,%rbp), %rcx
mulss 0x4(%rcx,%r13,8), %xmm0
addss %xmm0, %xmm1
incq %r13
jmp 0x3ea9
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x3f1e
minss 0x2208(%rip), %xmm1     # 0x6120
cvttss2si %xmm1, %eax
jmp 0x3f20
xorl %eax, %eax
movw %ax, 0x28(%rsp,%r14,2)
incq %r14
jmp 0x3e91
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %r8d
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq 0x20(%rsp), %r13
movl %r13d, %esi
movl %r12d, %edx
callq 0x2988
incq %r13
jmp 0x3e76
incl %r12d
jmp 0x3e69
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shirat74[P]resample/Resampler.cc
// Function: Resampler::resampleY(Image&, Image const&) const
void
Resampler::resampleY (Image& dst, const Image& src) const
{
  for (int32_t k = 0; k < dst.getWidth(); k++) {
    for (int32_t i = 0; i < dst.getHeight(); i++) {
      Color pixel;
      for (int c = 0; c < src.getNComps(); c++) {
        float weight = 0.0;
        for (int j = 0; j < contributor[i].n; j++) {
          weight +=
            src.getPixel(k, contributor[i].p[j].pixel).v[c] *
                                           contributor[i].p[j].weight;
        }
        pixel.v[c] = (uint16_t) MAP_IN_RANGE(weight, 0, 65535u);
      }
      dst.putPixel(k, i, pixel);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq %rsi, 0x18(%rsp)
cmpl (%r14), %r12d
jge 0x4086
xorl %r13d, %r13d
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jge 0x407e
movq %r13, 0x20(%rsp)
movq %r13, %rbp
shlq $0x5, %rbp
xorl %r14d, %r14d
movsbq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x4054
movq 0x10(%r15), %rax
xorps %xmm1, %xmm1
xorl %r13d, %r13d
movslq (%rax,%rbp), %rcx
cmpq %rcx, %r13
jge 0x402e
addq %rbp, %rax
movq 0x8(%rax), %rax
movl (%rax,%r13,8), %edx
movq %rbx, %rdi
movl %r12d, %esi
movss %xmm1, 0x4(%rsp)
callq 0x2900
movss 0x4(%rsp), %xmm1
movq %rax, 0x8(%rsp)
movw %dx, 0x10(%rsp)
shrl $0x10, %edx
movb %dl, 0x12(%rsp)
movzwl 0x8(%rsp,%r14,2), %eax
cvtsi2ss %eax, %xmm0
movq 0x10(%r15), %rax
movq 0x8(%rax,%rbp), %rcx
mulss 0x4(%rcx,%r13,8), %xmm0
addss %xmm0, %xmm1
incq %r13
jmp 0x3fcf
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x4044
minss 0x20e2(%rip), %xmm1     # 0x6120
cvttss2si %xmm1, %eax
jmp 0x4046
xorl %eax, %eax
movw %ax, 0x28(%rsp,%r14,2)
incq %r14
jmp 0x3fb7
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %r8d
movq 0x18(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movq 0x20(%rsp), %r13
movl %r13d, %edx
callq 0x2988
incq %r13
jmp 0x3f9b
incl %r12d
jmp 0x3f8f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/shirat74[P]resample/Resampler.cc
// Function: Resampler::resampleImage(Image const&, float, float)
Image
Resampler::resampleImage (const Image& src, float xsize, float ysize)
{
  float xScale, yScale;

  Image dst((uint32_t) xsize, (uint32_t) ysize, src.getNComps(), src.getBPC());

  xScale = (float) xsize / (float) src.getWidth();
  yScale = (float) ysize / (float) src.getHeight();

  // create intermediate image to hold horizontal zoom
  Image tmp(dst.getWidth(), src.getHeight(), src.getNComps(), src.getBPC());
  if (xScale < 1.0)
    setupContributorForDownsample(xScale, dst.getWidth(), src.getWidth());
  else
    setupContributorForUpsample  (xScale, dst.getWidth(), src.getWidth());
  resampleX(tmp, src);

  if (yScale < 1.0)
    setupContributorForDownsample(yScale, dst.getHeight(), src.getHeight());
  else
    setupContributorForUpsample  (yScale, dst.getHeight(), src.getHeight());
  resampleY(dst, tmp);

  return  dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movss %xmm0, 0xc(%rsp)
cvttss2si %xmm0, %rsi
movss %xmm1, 0x4(%rsp)
cvttss2si %xmm1, %rdx
movsbl 0x8(%r15), %ecx
movsbl 0x9(%r15), %r8d
callq 0x262c
cvtsi2ssl (%r15), %xmm0
movss %xmm0, 0x8(%rsp)
movl 0x4(%r15), %ebp
movl (%rbx), %esi
movsbl 0x8(%r15), %ecx
movsbl 0x9(%r15), %r8d
leaq 0x10(%rsp), %rdi
movl %ebp, %edx
callq 0x262c
movss 0xc(%rsp), %xmm0
divss 0x8(%rsp), %xmm0
movss 0x2007(%rip), %xmm1     # 0x6110
ucomiss %xmm0, %xmm1
movl (%rbx), %esi
movl (%r15), %edx
jbe 0x411d
movq %r14, %rdi
callq 0x3ae0
jmp 0x4125
movq %r14, %rdi
callq 0x3cc0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3e4a
cvtsi2ss %ebp, %xmm0
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss 0x1fc2(%rip), %xmm1     # 0x6110
ucomiss %xmm0, %xmm1
movl 0x4(%rbx), %esi
movl 0x4(%r15), %edx
jbe 0x4164
movq %r14, %rdi
callq 0x3ae0
jmp 0x416c
movq %r14, %rdi
callq 0x3cc0
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f70
leaq 0x10(%rsp), %rdi
callq 0x28f4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x41a6
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x28f4
movq %rbx, %rdi
callq 0x28f4
movq %r14, %rdi
callq 0x2420
// File: /workspace/github_cpp_makefile_star2_O2/shirat74[P]resample/./PNGImage.hh
// Function: PNGImage::getChromaticity() const
std::vector<float> getChromaticity() const {
    std::vector<float> cal(8);
    cal[0] = colorSpace.calRGB.xw;
    cal[1] = colorSpace.calRGB.yw;
    cal[2] = colorSpace.calRGB.xr;
    cal[3] = colorSpace.calRGB.yr;
    cal[4] = colorSpace.calRGB.xg;
    cal[5] = colorSpace.calRGB.yg;
    cal[6] = colorSpace.calRGB.xb;
    cal[7] = colorSpace.calRGB.yb;
    return cal;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %rsi
leaq 0x7(%rsp), %rdx
callq 0x4fb4
movss 0x64(%rbx), %xmm0
movq (%r14), %rax
movss %xmm0, (%rax)
movss 0x68(%rbx), %xmm0
movss %xmm0, 0x4(%rax)
movss 0x6c(%rbx), %xmm0
movss %xmm0, 0x8(%rax)
movss 0x70(%rbx), %xmm0
movss %xmm0, 0xc(%rax)
movss 0x74(%rbx), %xmm0
movss %xmm0, 0x10(%rax)
movss 0x78(%rbx), %xmm0
movss %xmm0, 0x14(%rax)
movss 0x7c(%rbx), %xmm0
movss %xmm0, 0x18(%rax)
movss 0x80(%rbx), %xmm0
movss %xmm0, 0x1c(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/aes_download_reverse.cpp
// Function: aes_decrypt(unsigned char*, unsigned char*, unsigned char*, unsigned int, unsigned int&, char*, char*)
int aes_decrypt(unsigned char *key, unsigned char *iv, unsigned char *ciphertext, unsigned int size, unsigned int &decryptedtext_len, char *remote_hash, char *filename)
{

	/* Buffer for the decrypted text */
	unsigned char *decryptedtext = (unsigned char *)malloc(size);
	if (decryptedtext == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	unsigned int ciphertext_len = size;

	decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv, decryptedtext);
	decryptedtext[decryptedtext_len] = '\0';

	char new_filename[256] = {0};



	unsigned char local_hash[33] = {0};

	md5sum((char *)decryptedtext, decryptedtext_len, (char *)&local_hash[0]);


	if (strcmp(remote_hash, (char *)&local_hash[0]) == 0)
	{
		printf("MD5 Hash Pass: %s\r\n", remote_hash);
	}
	else
	{
		printf("MD5 Hash Fail: local %s != remote %s\r\n", local_hash, remote_hash);
		free((void *)decryptedtext);
		return -1;
	}


	sprintf(new_filename, "%s_decrypted", filename);

	printf("Saving decrypted file as \"%s\"\r\n", new_filename);
	write_file(new_filename, (char *)decryptedtext, decryptedtext_len);
	free((void *)decryptedtext);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl %ecx, %edi
callq 0x2270
testq %rax, %rax
je 0x2dcb
movq %rax, %rbx
movq %r12, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x2bf6
movl %eax, %r14d
movq -0x38(%rbp), %r13
movl %eax, (%r13)
movl %eax, %eax
xorl %r15d, %r15d
movb %r15b, (%rbx,%rax)
leaq -0x160(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x2140
leaq -0x60(%rbp), %r12
movb %r15b, 0x20(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %rdx
callq 0x246f
movq -0x30(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2280
testl %eax, %eax
je 0x2d5e
leaq 0x3ed(%rip), %rdi       # 0x3137
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
pushq $-0x1
popq %r15
jmp 0x2dae
movq %r14, %rsi
movq 0x10(%rbp), %r14
leaq 0x3b7(%rip), %rdi       # 0x3123
xorl %eax, %eax
callq 0x2050
leaq 0x3e4(%rip), %rsi       # 0x315e
leaq -0x160(%rbp), %r12
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2070
leaq 0x3d6(%rip), %rdi       # 0x316b
movq %r12, %rsi
xorl %eax, %eax
callq 0x2050
movl (%r13), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x25c4
movq %rbx, %rdi
callq 0x2230
movl %r15d, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b4(%rip), %rdi       # 0x3086
callq 0x21b0
pushq $-0x1
popq %r15
jmp 0x2db6
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/aes_download_reverse.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;
	unsigned int max_malloc_size = 0;
	unsigned char encrypted_key[256] = {0};
	char remote_hash[33] = {0};

	if (argc < 4)
	{
		printf("Usage: aes_download_reverse port max_size prikey\r\n");
		printf("Example: ./aes_download_reverse 65535 70912 id_rsa\r\n");
		return 0;
	}

	port = atoi(argv[1]);
	max_malloc_size = atoi(argv[2]);

	unsigned int prikey_size = 0;
	unsigned char *prikey = (unsigned char *)get_file(argv[3], &prikey_size);


	printf("Waiting for download file on port %d\r\n", (int)port);
	int ret = aes_file_download_reverse(port, prikey, max_malloc_size);

	delete [] prikey;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jg 0x2e06
leaq 0x54a(%rip), %rdi       # 0x333d
callq 0x22a0
leaq 0x570(%rip), %rdi       # 0x336f
callq 0x22a0
jmp 0x2e64
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x22b0
movl %eax, %r14d
movq 0x10(%rbx), %rdi
callq 0x22b0
movl %eax, %r15d
leaq -0x1c(%rbp), %rsi
andl $0x0, (%rsi)
movq 0x18(%rbx), %rdi
callq 0x2516
movq %rax, %rbx
movzwl %r14w, %r14d
leaq 0x412(%rip), %rdi       # 0x3251
movl %r14d, %esi
xorl %eax, %eax
callq 0x2050
movl %r14d, %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x263d
testq %rbx, %rbx
je 0x2e64
movq %rbx, %rdi
callq 0x2250
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/oknenavin[P]cxon/examples/format-traits-ex02.cxx
// Function: main
int main() {
    std::map<std::string, std::string> cxx;
        cxon::from_bytes<UQK>(cxx, R"({ key: 'value' })");
    assert(cxx == (std::map<std::string, std::string> { {"key", "value"} }));
    std::string str;
        cxon::to_bytes<UQK>(str, cxx);
    assert(str == R"({key:'value'})");
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
leaq 0x58(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x304f(%rip), %rdx      # 0x5384
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2598
leaq 0x304a(%rip), %rsi      # 0x5395
leaq 0x3047(%rip), %rdx      # 0x5399
leaq 0x10(%rsp), %rdi
callq 0x2482
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
leaq 0xe(%rsp), %r8
callq 0x24d8
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x3d94
testb %al, %al
je 0x2404
leaq 0x80(%rsp), %rdi
callq 0x2538
leaq 0x10(%rsp), %rdi
callq 0x24c2
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x3e5a
leaq 0x302b(%rip), %rsi      # 0x5402
leaq 0x10(%rsp), %rdi
callq 0x2520
testb %al, %al
je 0x241d
leaq 0x10(%rsp), %rdi
callq 0x20c0
leaq 0x50(%rsp), %rdi
callq 0x2538
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
leaq 0x2f94(%rip), %rdi      # 0x539f
leaq 0x2fce(%rip), %rsi      # 0x53e0
leaq 0x2fde(%rip), %rcx      # 0x53f7
pushq $0x15
jmp 0x2434
leaq 0x2fec(%rip), %rdi      # 0x5410
leaq 0x2fb5(%rip), %rsi      # 0x53e0
leaq 0x2fc5(%rip), %rcx      # 0x53f7
pushq $0x18
popq %rdx
callq 0x2100
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0x246f
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x2538
jmp 0x245e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24c2
jmp 0x246f
jmp 0x246c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2538
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/main.cc
// Function: advance_cycle()
bool advance_cycle() {
    cycles++;
    //status();
    if(FE_continue || DE_register.size() || RN_register.size() || RR_register.size()
            || DI_register.size() || !isIQempty() || execute_list.size()
            || WB_register.size() || !isROBempty()) return true;
    else return false;
}

// Assembly:
pushq %rbx
incl 0x67c2(%rip)            # 0x917c
movb $0x1, %bl
cmpl $0x0, 0x6a2d(%rip)      # 0x93f0
jne 0x2a3d
leaq 0x6a2c(%rip), %rdi      # 0x93f8
callq 0x2ea4
testq %rax, %rax
jne 0x2a3d
leaq 0x6a6b(%rip), %rdi      # 0x9448
callq 0x2ea4
testq %rax, %rax
jne 0x2a3d
leaq 0x6aaa(%rip), %rdi      # 0x9498
callq 0x2ea4
testq %rax, %rax
jne 0x2a3d
leaq 0x6ae9(%rip), %rdi      # 0x94e8
callq 0x2ea4
testq %rax, %rax
jne 0x2a3d
callq 0x2a41
testb %al, %al
je 0x2a3d
movq 0x69c7(%rip), %rax      # 0x93e0
cmpq 0x69b8(%rip), %rax      # 0x93d8
jne 0x2a3d
leaq 0x6b0f(%rip), %rdi      # 0x9538
callq 0x2ea4
testq %rax, %rax
jne 0x2a3d
callq 0x2a7e
movl %eax, %ebx
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/main.cc
// Function: isIQempty()
bool isIQempty() {
    bool empty = true;
    for(u_int i=0; i<IQ_SIZE; i++)
        if(IQ.at(i).valid) empty = false;
    return empty;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, %bl
xorl %r14d, %r14d
leaq 0x696e(%rip), %r15      # 0x93c0
movl 0x6710(%rip), %eax      # 0x9168
cmpq %rax, %r14
jae 0x2a73
movq %r15, %rdi
movq %r14, %rsi
callq 0x2eb4
movb (%rax), %al
xorb $0x1, %al
andb %al, %bl
incq %r14
jmp 0x2a52
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/main.cc
// Function: isROBempty()
bool isROBempty() {
    bool empty = true;
    for(u_int i=0; i<ROBSIZE; i++)
        if(ROB.at(i).valid) empty = false;
    return empty;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, %bl
xorl %r14d, %r14d
leaq 0x6901(%rip), %r15      # 0x9390
movl 0x66cf(%rip), %eax      # 0x9164
cmpq %rax, %r14
jae 0x2ab0
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ed6
movb (%rax), %al
xorb $0x1, %al
andb %al, %bl
incq %r14
jmp 0x2a8f
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/main.cc
// Function: status()
void status () {

    cout << "DE_register: " << DE_register.size() << endl;
    cout << "RN_register: " << RN_register.size() << endl;
    cout << "RR_register: " << RR_register.size() << endl;
    cout << "DI_register: " << DI_register.size() << endl;
    cout << "Is IQ Empty: " << isIQempty() << endl;
    cout << "execute_list: " << execute_list.size() << endl;
    cout << "WB_register: " << WB_register.size() << endl;
    cout << "Is ROB Empty: " << isROBempty() << endl;
    cout << "cycles: " << cycles << endl;
    robstatus();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x6512(%rip), %rbx      # 0x8fd8
leaq 0x3716(%rip), %rsi      # 0x61e3
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
leaq 0x6919(%rip), %rdi      # 0x93f8
callq 0x2ea4
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
leaq 0x36f3(%rip), %rsi      # 0x61f1
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
leaq 0x6938(%rip), %rdi      # 0x9448
callq 0x2ea4
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
leaq 0x36d0(%rip), %rsi      # 0x61ff
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
leaq 0x6957(%rip), %rdi      # 0x9498
callq 0x2ea4
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
leaq 0x36ad(%rip), %rsi      # 0x620d
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
leaq 0x6976(%rip), %rdi      # 0x94e8
callq 0x2ea4
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
leaq 0x368a(%rip), %rsi      # 0x621b
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
callq 0x2a41
movzbl %al, %esi
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x366e(%rip), %rsi      # 0x6229
movq %rbx, %rdi
callq 0x2140
movq 0x6816(%rip), %rsi      # 0x93e0
subq 0x6807(%rip), %rsi      # 0x93d8
sarq $0x7, %rsi
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
leaq 0x364c(%rip), %rsi      # 0x6238
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
leaq 0x693a(%rip), %rdi      # 0x9538
callq 0x2ea4
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
leaq 0x3629(%rip), %rsi      # 0x6246
movq %rbx, %rdi
callq 0x2140
movq %rax, %r14
callq 0x2a7e
movzbl %al, %esi
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
callq 0x20b0
leaq 0x360e(%rip), %rsi      # 0x6255
movq %rbx, %rdi
callq 0x2140
movl 0x6527(%rip), %esi      # 0x917c
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c71
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/main.cc
// Function: robstatus()
void robstatus() {
    cout << "ROB -------------------" << endl;
    for(u_int i=0; i < ROB.size(); i++) {
        cout << i << ": " << "val " << ROB.at(i).valid << " ready "
             << ROB.at(i).ready;
        if(head == i) cout << " HEAD ";
        if(tail == i) cout << " TAIL ";
        cout << endl;
    }
        cout << "the address of this is..." << ROB.at(head).address << endl;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x6355(%rip), %rbx      # 0x8fd8
leaq 0x35d4(%rip), %rsi      # 0x625e
movq %rbx, %rdi
callq 0x2140
movq %rax, %rdi
callq 0x20b0
xorl %r14d, %r14d
movl $0x98, %r12d
leaq 0x66e6(%rip), %r13      # 0x9390
leaq 0x35ca(%rip), %rbp      # 0x627b
movl %r14d, %r14d
movq 0x66dd(%rip), %rax      # 0x9398
subq 0x66ce(%rip), %rax      # 0x9390
cqto
idivq %r12
cmpq %r14, %rax
jbe 0x2d77
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
movq %rax, %rdi
leaq 0x36d5(%rip), %rsi      # 0x63ba
callq 0x2140
movq %rax, %rdi
leaq 0x3582(%rip), %rsi      # 0x6276
callq 0x2140
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x2ed6
movzbl (%rax), %esi
movq %r15, %rdi
callq 0x2220
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2140
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x2ed6
movzbl 0x8(%rax), %esi
movq %r15, %rdi
callq 0x2220
cmpl 0x640a(%rip), %r14d     # 0x9148
jne 0x2d4f
movq %rbx, %rdi
leaq 0x3539(%rip), %rsi      # 0x6283
callq 0x2140
cmpl 0x63f6(%rip), %r14d     # 0x914c
jne 0x2d67
movq %rbx, %rdi
leaq 0x3528(%rip), %rsi      # 0x628a
callq 0x2140
movq %rbx, %rdi
callq 0x20b0
incl %r14d
jmp 0x2cb1
movq 0x625a(%rip), %rdi      # 0x8fd8
leaq 0x350c(%rip), %rsi      # 0x6291
callq 0x2140
movq %rax, %rbx
movl 0x63b5(%rip), %esi      # 0x9148
leaq 0x65f6(%rip), %rdi      # 0x9390
callq 0x2ed6
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x20f0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/rename.cc
// Function: isrobfull()
bool isrobfull() {
    u_int empty_slots=ROBSIZE;
    for(u_int i=0; i<ROB.size(); i++) {
        if(ROB.at(i).valid) empty_slots--;
    }
    return (empty_slots < WIDTH) ? true : false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x51d6(%rip), %rax      # 0x9164
movl (%rax), %ebp
xorl %eax, %eax
leaq 0x53f7(%rip), %rbx      # 0x9390
movl $0x98, %r15d
movl %eax, %r14d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r15
cmpq %r14, %rax
jbe 0x3fc9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ed6
movzbl (%rax), %eax
subl %eax, %ebp
leal 0x1(%r14), %eax
jmp 0x3f9f
leaq 0x519c(%rip), %rax      # 0x916c
cmpl (%rax), %ebp
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/dispatch.cc
// Function: isiqfull()
bool isiqfull() {
    u_int empty_slots=IQ_SIZE;
    for(u_int i=0; i<IQ_SIZE; i++) {
        if(IQ.at(i).valid) empty_slots--;
    }
    return (empty_slots < WIDTH) ? true : false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4dbd(%rip), %r15      # 0x9168
movl (%r15), %eax
xorl %ebx, %ebx
leaq 0x5009(%rip), %r14      # 0x93c0
movl %eax, %ebp
movl %eax, %eax
cmpq %rax, %rbx
jae 0x43d8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eb4
movzbl (%rax), %eax
subl %eax, %ebp
incq %rbx
movl (%r15), %eax
jmp 0x43b9
leaq 0x4d8d(%rip), %rax      # 0x916c
cmpl (%rax), %ebp
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/issue.cc
// Function: ready(unsigned int)
bool ready(u_int index) {
    bool status = true;
    if(IQ.at(index).instruction.rn_src_1 != -1) status = false;
    if(IQ.at(index).instruction.rn_src_2 != -1) status = false;
    return status;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x4dbc(%rip), %r14      # 0x93c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eb4
movl 0x20(%rax), %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2eb4
andl 0x28(%rax), %ebp
cmpl $-0x1, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dsesami[P]superscalar-processor-model/execute.cc
// Function: execute_needed()
bool execute_needed() {
    bool yes = false;
    for(u_int i=0; i<execute_list.size(); i++) {
        if(!execute_list.at(i).age) yes = true;
    }
    return yes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
leaq 0x492c(%rip), %r14      # 0x93d8
xorl %eax, %eax
movl %eax, %r15d
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x7, %rax
cmpq %r15, %rax
jbe 0x4adb
movq %r14, %rdi
movq %r15, %rsi
callq 0x4baa
cmpl $0x0, 0x78(%rax)
sete %al
orb %al, %bl
leal 0x1(%r15), %eax
jmp 0x4aae
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/theanarkh[P]js_runtime_loader/core/process.cc
// Function: No::Process::Init(v8::Isolate*, v8::Local<v8::Object>, char**, int)
void No::Process::Init(Isolate* isolate, Local<Object> target, char ** argv, int argc) {
  Local<Context> context = isolate->GetCurrentContext();
  Local<ObjectTemplate> process = ObjectTemplate::New(isolate);
  Local<Object> obj = process->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();

  Local<Array> arr = Array::New(isolate, argc);
  for (int i = 0; i < argc; i++) {
      arr->Set(context, Number::New(isolate, i), newStringToLcal(isolate, argv[i]));
  }
  setObjectValue(isolate, obj, "argv", arr);
  setObjectValue(isolate, target, "process", obj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdx, -0x48(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
callq 0x100220
movq %rax, -0x40(%rbp)
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0xfa150
movq %rax, %rbx
movq %r14, %rdi
callq 0x100220
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11da40
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0xf0518
movq %r14, %rdi
movl %r15d, %esi
callq 0x1218a0
movq %rax, %rbx
testl %r15d, %r15d
cmovlel %r13d, %r15d
cmpq %r13, %r15
je 0xf04db
cvtsi2sd %r13d, %xmm0
movq %r14, %rdi
callq 0x12a4b0
movq %rax, %r12
movq -0x48(%rbp), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xf0546
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x10de50
incq %r13
jmp 0xf049d
leaq 0xdf3b52(%rip), %rdx    # 0xee4034
movq %r14, %rdi
movq -0x30(%rbp), %r15
movq %r15, %rsi
movq %rbx, %rcx
callq 0xf0651
leaq 0xdf3b3e(%rip), %rdx    # 0xee4039
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf0651
callq 0xf73f0
jmp 0xf0488
nop
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/performance_tests.cpp
// Function: BenchPattern2String[abi:cxx11](BenchPattern_t)
std::string BenchPattern2String(BenchPattern_t t)
{
    switch (t) {
    case BENCH_PATTERN_CONTINUOUS_ALLOCATION:
        return "Continuous allocations, bulk free at end";
    case BENCH_PATTERN_MIXED_ALLOC_FREE:
        return "Mixed alloc/free pattern";
    default:
        return "";
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x1, %esi
je 0x236b
testl %esi, %esi
jne 0x2379
leaq 0x2cf4(%rip), %rsi      # 0x5058
leaq 0xf(%rsp), %rdx
jmp 0x2385
leaq 0x2d0f(%rip), %rsi      # 0x5081
leaq 0xe(%rsp), %rdx
jmp 0x2385
leaq 0x39e4(%rip), %rsi      # 0x5d64
leaq 0xd(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/performance_tests.cpp
// Function: main
int main(int argc, char** argv)
{
    if (argc > 1)
        usage(argv[0]);

    // to better simulate a realistic workload use our own benchmarking routines to
    // defrag a little bit the memory of this process (but do not really write any output!)
    for (unsigned int i = 0; i < 3; i++)
        do_benchmark(NULL);

    // final run is to write real output JSON
    do_json_benchmark();

    return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x23f0
pushq $0x3
popq %rbx
subl $0x1, %ebx
jb 0x23b1
xorl %edi, %edi
callq 0x2413
jmp 0x23a3
movq 0x6c10(%rip), %rax      # 0x8fc8
movq (%rax), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4bcc
movq %rbx, %rdi
callq 0x4bd7
movq %rbx, %rdi
callq 0x2413
movq %rbx, %rdi
callq 0x4c44
pushq $0xa
popq %rdi
callq 0x21d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movq (%rsi), %rdx
movq 0x6be6(%rip), %rax      # 0x8fe0
movq (%rax), %rdi
leaq 0x2c96(%rip), %rsi      # 0x509a
xorl %eax, %eax
callq 0x21e0
pushq $0x1
popq %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/include/boost_intrusive_pool.hpp
// Function: memorypool::boost_intrusive_pool<LargeObject>::impl::get_effective_enlarge_step() const
size_t get_effective_enlarge_step() const
        {
            size_t enlarge_step = m_enlarge_step;
            if (m_enlarge_step > 0 && (m_max_size > 0 && (m_total_count + m_enlarge_step > m_max_size)))
                enlarge_step = m_max_size - m_total_count; // enlarge_step can be zero if we reach the max_size
            return enlarge_step;
        }

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4313
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x4312
movq 0x70(%rdi), %rdx
movq %rcx, %rsi
subq %rdx, %rsi
addq %rax, %rdx
cmpq %rcx, %rdx
cmovaq %rsi, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_document_begin(json_ctx*)
void json_document_begin(json_ctx_t* ctx)
{
    do_indent(ctx);

    fputs("{\n", ctx->fp);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4bf8
movq (%rbx), %rsi
leaq 0x1181(%rip), %rdi      # 0x5d6b
callq 0x2150
incl 0x8(%rbx)
movb $0x1, 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: do_indent(json_ctx*)
static void do_indent(json_ctx_t* ctx)
{
    char indent_buf[ctx->indent_level + 1];

    memset(indent_buf, ' ', ctx->indent_level + 1);
    indent_buf[ctx->indent_level] = '\0';

    fputs(indent_buf, ctx->fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
leal 0x1(%r15), %edx
movq %rsp, %r14
leaq 0xf(%rdx), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x20d0
movb $0x0, (%r15,%r14)
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_object_begin(json_ctx*, char const*)
void json_attr_object_begin(json_ctx_t* ctx, const char* name)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": {\n", name);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
jne 0x4c85
movq (%rbx), %rcx
leaq 0x10e8(%rip), %rdi      # 0x5d62
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
movq %rbx, %rdi
callq 0x4bf8
movq (%rbx), %rdi
leaq 0x10ce(%rip), %rsi      # 0x5d65
movq %r14, %rdx
xorl %eax, %eax
callq 0x21e0
incl 0x8(%rbx)
movb $0x1, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_object_end(json_ctx*)
void json_attr_object_end(json_ctx_t* ctx)
{
    ctx->indent_level--;
    ctx->first_element = false;

    fputs("\n", ctx->fp);

    do_indent(ctx);

    fputs("}", ctx->fp);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
decl 0x8(%rdi)
movb $0x0, 0xc(%rdi)
movq (%rdi), %rsi
leaq 0x109e(%rip), %rdi      # 0x5d63
callq 0x2150
movq %rbx, %rdi
callq 0x4bf8
movq (%rbx), %rsi
leaq 0x1084(%rip), %rdi      # 0x5d60
popq %rbx
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_string(json_ctx*, char const*, char const*)
void json_attr_string(json_ctx_t* ctx, const char* name, const char* s)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": \"%s\"", name, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xc(%rdi)
je 0x4cfd
movb $0x0, 0xc(%r15)
jmp 0x4d12
movq (%r15), %rcx
leaq 0x105b(%rip), %rdi      # 0x5d62
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
movq %r15, %rdi
callq 0x4bf8
movq (%r15), %rdi
leaq 0x104a(%rip), %rsi      # 0x5d6e
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_uint(json_ctx*, char const*, unsigned long)
void json_attr_uint(json_ctx_t* ctx, const char* name, uint64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": %" PRIu64, name, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xc(%rdi)
je 0x4d51
movb $0x0, 0xc(%r15)
jmp 0x4d66
movq (%r15), %rcx
leaq 0x1007(%rip), %rdi      # 0x5d62
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
movq %r15, %rdi
callq 0x4bf8
movq (%r15), %rdi
leaq 0x1001(%rip), %rsi      # 0x5d79
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_int(json_ctx*, char const*, long)
void json_attr_int(json_ctx_t* ctx, const char* name, int64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": %" PRId64, name, d);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0xc(%rdi)
je 0x4da5
movb $0x0, 0xc(%r15)
jmp 0x4dba
movq (%r15), %rcx
leaq 0xfb3(%rip), %rdi       # 0x5d62
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
movq %r15, %rdi
callq 0x4bf8
movq (%r15), %rdi
leaq 0xfb7(%rip), %rsi       # 0x5d83
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_attr_double(json_ctx*, char const*, double)
void json_attr_double(json_ctx_t* ctx, const char* name, double d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");
    else
        ctx->first_element = false;

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": %g", name, d);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0xc(%rdi)
je 0x4dfa
movb $0x0, 0xc(%r14)
jmp 0x4e0f
movq (%r14), %rcx
leaq 0xf5e(%rip), %rdi       # 0x5d62
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
movq %r14, %rdi
callq 0x4bf8
movq (%r14), %rdi
leaq 0xf6c(%rip), %rsi       # 0x5d8d
movq %rbx, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_array_begin(json_ctx*, char const*)
void json_array_begin(json_ctx_t* ctx, const char* name)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",\n");

    do_indent(ctx);

    fprintf(ctx->fp, "\"%s\": [", name);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
jne 0x4e5c
movq (%rbx), %rcx
leaq 0xf11(%rip), %rdi       # 0x5d62
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x2230
movq %rbx, %rdi
callq 0x4bf8
movq (%rbx), %rdi
leaq 0xf28(%rip), %rsi       # 0x5d96
movq %r14, %rdx
xorl %eax, %eax
callq 0x21e0
incl 0x8(%rbx)
movb $0x1, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_string(json_ctx*, char const*)
void json_element_string(json_ctx_t* ctx, const char* s)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", \"%s\"", s);
    else {
        fprintf(ctx->fp, "\"%s\"", s);
        ctx->first_element = false;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x0, 0xc(%rbx)
je 0x4ec1
leaq 0xeec(%rip), %rsi       # 0x5da0
xorl %eax, %eax
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0xed6(%rip), %rsi       # 0x5d9e
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_uint(json_ctx*, unsigned long)
void json_element_uint(json_ctx_t* ctx, uint64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", %" PRIu64, d);
    else {
        fprintf(ctx->fp, "%" PRIu64, d);
        ctx->first_element = false;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x0, 0xc(%rbx)
je 0x4ef4
leaq 0xec0(%rip), %rsi       # 0x5da7
xorl %eax, %eax
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0xeaa(%rip), %rsi       # 0x5da5
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_int(json_ctx*, long)
void json_element_int(json_ctx_t* ctx, int64_t d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", %" PRId64, d);
    else {
        fprintf(ctx->fp, "%" PRId64, d);
        ctx->first_element = false;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x0, 0xc(%rbx)
je 0x4f27
leaq 0xe93(%rip), %rsi       # 0x5dad
xorl %eax, %eax
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0xe7d(%rip), %rsi       # 0x5dab
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_double(json_ctx*, double)
void json_element_double(json_ctx_t* ctx, double d)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ", %g", d);
    else {
        fprintf(ctx->fp, "%g", d);
        ctx->first_element = false;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpb $0x0, 0xc(%rbx)
je 0x4f57
leaq 0xe69(%rip), %rsi       # 0x5db3
movb $0x1, %al
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0xe53(%rip), %rsi       # 0x5db1
movb $0x1, %al
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/f18m[P]boost-intrusive-pool/tests/json-lib.cpp
// Function: json_element_object_begin(json_ctx*)
void json_element_object_begin(json_ctx_t* ctx)
{
    if (!ctx->first_element)
        fprintf(ctx->fp, ",");

    fputs("\n", ctx->fp);

    do_indent(ctx);

    fputs("{\n", ctx->fp);

    ctx->indent_level++;
    ctx->first_element = true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xc(%rdi)
jne 0x4f7b
movq (%rbx), %rsi
pushq $0x2c
popq %rdi
callq 0x2190
movq (%rbx), %rsi
leaq 0xdde(%rip), %rdi       # 0x5d63
callq 0x2150
movq %rbx, %rdi
callq 0x4bf8
movq (%rbx), %rsi
leaq 0xdcf(%rip), %rdi       # 0x5d6b
callq 0x2150
incl 0x8(%rbx)
movb $0x1, 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Dalgona[P]mine/reset-scores.cpp
// Function: main
int main(void)
{
  std::cout << "Opening scores.dat for writing...\n";
  std::ofstream file("scores.dat", std::ios::out | std::ios::binary);
  std::cout << "Writing blank score data...\n";
  for (int i = 0; i < 15; i++)
  {
    file << "__________";
    file.write("\x00\xff\xff\xff\x7f", 5);
  }
  std::cout << "Closing file...\n";
  file.close();
  std::cout << "Score data were reset successfully.\n";
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq 0x2de6(%rip), %rbx      # 0x3fd8
leaq 0xe0b(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1040
leaq 0xe1f(%rip), %rsi       # 0x2027
movq %rsp, %rdi
pushq $0x14
popq %rdx
callq 0x1050
leaq 0xe18(%rip), %rsi       # 0x2032
movq %rbx, %rdi
callq 0x1040
pushq $0xf
popq %rbp
leaq 0xe23(%rip), %rbx       # 0x204f
movq %rsp, %r14
leaq 0xe5a(%rip), %r15       # 0x2090
pushq $0x5
popq %r12
subl $0x1, %ebp
jb 0x125a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1040
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1060
jmp 0x123a
movq 0x2d77(%rip), %rdi      # 0x3fd8
leaq 0xdf2(%rip), %rsi       # 0x205a
callq 0x1040
movq %rsp, %rdi
callq 0x1070
movq 0x2d5c(%rip), %rdi      # 0x3fd8
leaq 0xde8(%rip), %rsi       # 0x206b
callq 0x1040
movq %rsp, %rdi
callq 0x1080
xorl %eax, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12a4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: stringify[abi:cxx11](std::vector<int, std::allocator<int>>)
std::string stringify(std::vector<int> values) {
    std::stringstream ss;
    ss << "[";
    if (values.size() > 0) {
        std::copy(values.begin(), values.end() - 1, std::ostream_iterator<int>(ss, " -> "));
        ss << *(values.end() - 1);
    }
    ss << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0xd4b0
leaq -0x1b0(%rbp), %r14
leaq 0x9df4(%rip), %rsi      # 0x18000
movq %r14, %rdi
callq 0xd7b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
cmpq %rsi, %rdx
je 0xe24e
addq $-0x4, %rdx
leaq -0x38(%rbp), %rcx
movq %r14, (%rcx)
leaq 0x9dd0(%rip), %rax      # 0x18002
movq %rax, 0x8(%rcx)
leaq -0x28(%rbp), %rdi
callq 0xd920
movq 0x8(%r15), %rax
movl -0x4(%rax), %esi
movq %r14, %rdi
callq 0xdd20
leaq 0xa40c(%rip), %rsi      # 0x18661
movq %r14, %rdi
callq 0xd7b0
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0xdc20
leaq -0x1c0(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe28d
jmp 0xe28d
movq %rax, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rdi
callq 0xddb0
// File: /workspace/github_cpp_makefile_star2_O2/pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: stringify[abi:cxx11](std::initializer_list<int>)
std::string stringify(std::initializer_list<int> values) {
    std::stringstream ss;
    ss << "[";
    if (values.size() > 0) {
        std::copy(values.begin(), values.end() - 1, std::ostream_iterator<int>(ss, " -> "));
        ss << *(values.end() - 1);
    }
    ss << "]";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0xd4b0
leaq -0x1b8(%rbp), %r14
leaq 0x9d27(%rip), %rsi      # 0x18000
movq %r14, %rdi
callq 0xd7b0
testq %r12, %r12
je 0xe31b
leaq (%r15,%r12,4), %r12
addq $-0x4, %r12
leaq -0x40(%rbp), %rcx
movq %r14, (%rcx)
leaq 0x9d06(%rip), %rax      # 0x18002
movq %rax, 0x8(%rcx)
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xd050
movl (%r12), %esi
movq %r14, %rdi
callq 0xdd20
leaq 0xa33f(%rip), %rsi      # 0x18661
movq %r14, %rdi
callq 0xd7b0
leaq -0x1b0(%rbp), %rsi
movq %rbx, %rdi
callq 0xdc20
leaq -0x1c8(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe35a
movq %rax, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0xd4d0
movq %rbx, %rdi
callq 0xddb0
nop