LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x20(%rdi)
leaq -0x3fa(%rip), %rax      # 0x3924
movq %rax, (%rdi)
movl $0x3f000000, 0x8(%rdi)  # imm = 0x3F000000
xorl %r15d, %r15d
leaq 0x4f2e(%rip), %r12      # 0x8c60
leaq (%r12,%r15), %rsi
movq %r14, %rdi
callq 0x20c0
testl %eax, %eax
je 0x3d51
addq $0x30, %r15
cmpq $0x120, %r15            # imm = 0x120
jne 0x3d32
jmp 0x3d65
movq 0x20(%r15,%r12), %rax
movq %rax, (%rbx)
movss 0x28(%r15,%r12), %xmm0
movss %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rdx, 0x10(%rsp)
movl %esi, %ebp
movss %xmm0, 0xc(%rsp)
movq %rdi, %r14
leaq 0x10(%rdi), %r15
movslq %esi, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x4562
testl %r12d, %r12d
jle 0x412f
movl %ebp, %eax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
leal -0x1(,%rax,2), %r13d
xorl %ebx, %ebx
movq 0x10(%r14), %rax
movq %rbx, %rbp
shlq $0x5, %rbp
movl $0x0, (%rax,%rbp)
movss 0x8(%r14), %xmm0
addss %xmm0, %xmm0
addss 0x212f(%rip), %xmm0     # 0x6154
cvttss2si %xmm0, %eax
movslq %eax, %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0x4592
movq 0x10(%r14), %rax
leaq (%rax,%rbp), %rdi
addq $0x8, %rdi
movq %r12, %rsi
callq 0x4624
movq %rbx, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
divss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%r14), %xmm2
movss %xmm2, (%rsp)
subss %xmm2, %xmm0
callq 0x21a0
movaps %xmm0, 0x40(%rsp)
movss (%rsp), %xmm0
addss 0x8(%rsp), %xmm0
callq 0x2100
movaps 0x40(%rsp), %xmm2
cvttps2dq %xmm2, %xmm1
cvtdq2ps %xmm1, %xmm1
movss %xmm0, (%rsp)
ucomiss %xmm1, %xmm0
jb 0x4105
cvttss2si %xmm2, %r12d
movl %r12d, %ebx
negl %ebx
movss 0x8(%rsp), %xmm0
subss %xmm1, %xmm0
callq *(%r14)
leal (%rbx,%r13), %eax
cmpl 0x10(%rsp), %r12d
cmovll %r12d, %eax
testl %r12d, %r12d
cmovsl %ebx, %eax
movq (%r15), %rcx
movslq (%rcx,%rbp), %rdx
leal 0x1(%rdx), %esi
movl %esi, (%rcx,%rbp)
movq 0x8(%rcx,%rbp), %rcx
movl %eax, (%rcx,%rdx,8)
incl %r12d
xorps %xmm1, %xmm1
cvtsi2ss %r12d, %xmm1
movss %xmm0, 0x4(%rcx,%rdx,8)
decl %ebx
movss (%rsp), %xmm0
ucomiss %xmm1, %xmm0
jae 0x40b3
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x411c
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x22d0
movq 0x20(%rsp), %rbx
incq %rbx
cmpq 0x18(%rsp), %rbx
jne 0x4001
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4140
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x415a
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x22d0
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, 0x4(%rsi)
jle 0x42a7
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, 0x20(%rsp)
cmpl $0x0, (%r14)
jle 0x428c
movq $0x0, (%rsp)
cmpb $0x0, 0x8(%rbx)
jle 0x4258
movq (%rsp), %rbp
shlq $0x5, %rbp
xorl %r14d, %r14d
movq 0x10(%r15), %rax
cmpl $0x0, (%rax,%rbp)
jle 0x4226
xorps %xmm1, %xmm1
xorl %r13d, %r13d
movss %xmm1, 0xc(%rsp)
movq 0x8(%rax,%rbp), %rax
movl (%rax,%r13,8), %esi
movq %rbx, %rdi
movl %r12d, %edx
callq 0x2a1e
movss 0xc(%rsp), %xmm1
movq %rax, 0x10(%rsp)
movw %dx, 0x18(%rsp)
shrl $0x10, %edx
movb %dl, 0x1a(%rsp)
movzwl 0x10(%rsp,%r14,2), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movq 0x10(%r15), %rax
movq 0x8(%rax,%rbp), %rax
mulss 0x4(%rax,%r13,8), %xmm0
addss %xmm0, %xmm1
incq %r13
movq 0x10(%r15), %rax
movslq (%rax,%rbp), %rcx
cmpq %rcx, %r13
jl 0x41c2
jmp 0x4229
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x423f
minss 0x1f2b(%rip), %xmm1     # 0x6164
cvttss2si %xmm1, %eax
jmp 0x4241
xorl %eax, %eax
movw %ax, 0x28(%rsp,%r14,2)
incq %r14
movsbq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x41b2
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %r8d
movq 0x20(%rsp), %r14
movq %r14, %rdi
movq (%rsp), %r13
movl %r13d, %esi
movl %r12d, %edx
callq 0x2a68
incq %r13
movslq (%r14), %rax
movq %r13, (%rsp)
cmpq %rax, %r13
jl 0x419d
incl %r12d
cmpl 0x4(%r14), %r12d
jl 0x418b
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x0, (%rsi)
jle 0x43ed
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, 0x20(%rsp)
cmpl $0x0, 0x4(%r14)
jle 0x43d3
movq $0x0, (%rsp)
cmpb $0x0, 0x8(%rbx)
jle 0x439e
movq (%rsp), %rbp
shlq $0x5, %rbp
xorl %r14d, %r14d
movq 0x10(%r15), %rax
cmpl $0x0, (%rax,%rbp)
jle 0x436c
xorps %xmm1, %xmm1
xorl %r13d, %r13d
movss %xmm1, 0xc(%rsp)
movq 0x8(%rax,%rbp), %rax
movl (%rax,%r13,8), %edx
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2a1e
movss 0xc(%rsp), %xmm1
movq %rax, 0x10(%rsp)
movw %dx, 0x18(%rsp)
shrl $0x10, %edx
movb %dl, 0x1a(%rsp)
movzwl 0x10(%rsp,%r14,2), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movq 0x10(%r15), %rax
movq 0x8(%rax,%rbp), %rax
mulss 0x4(%rax,%r13,8), %xmm0
addss %xmm0, %xmm1
incq %r13
movq 0x10(%r15), %rax
movslq (%rax,%rbp), %rcx
cmpq %rcx, %r13
jl 0x4308
jmp 0x436f
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jae 0x4385
minss 0x1de5(%rip), %xmm1     # 0x6164
cvttss2si %xmm1, %eax
jmp 0x4387
xorl %eax, %eax
movw %ax, 0x28(%rsp,%r14,2)
incq %r14
movsbq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x42f8
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %r8d
movq 0x20(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movq (%rsp), %r13
movl %r13d, %edx
callq 0x2a68
incq %r13
movslq 0x4(%r14), %rax
movq %r13, (%rsp)
cmpq %rax, %r13
jl 0x42e3
incl %r12d
cmpl (%r14), %r12d
jl 0x42d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x260c
xorps %xmm0, %xmm0
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 0x260c
movss 0xc(%rsp), %xmm0
divss 0x8(%rsp), %xmm0
movss 0x1cf0(%rip), %xmm1     # 0x6154
ucomiss %xmm0, %xmm1
movl (%rbx), %esi
movl (%r15), %edx
jbe 0x4478
movq %r14, %rdi
callq 0x3d7c
jmp 0x4480
movq %r14, %rdi
callq 0x3fb2
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x4162
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
movss 0x1ca8(%rip), %xmm1     # 0x6154
ucomiss %xmm0, %xmm1
movl 0x4(%rbx), %esi
movl 0x4(%r15), %edx
jbe 0x44c2
movq %r14, %rdi
callq 0x3d7c
jmp 0x44ca
movq %r14, %rdi
callq 0x3fb2
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42a8
leaq 0x10(%rsp), %rdi
callq 0x2a0a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4504
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2a0a
movq %rbx, %rdi
callq 0x2a0a
movq %r14, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e63
movq %rax, %rbx
movq %r12, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x2c7d
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 0x2467
movq -0x30(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2280
testl %eax, %eax
je 0x2df6
leaq 0x357(%rip), %rdi       # 0x3137
leaq -0x60(%rbp), %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2050
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x2e46
movq %r14, %rsi
movq 0x10(%rbp), %r14
leaq 0x31f(%rip), %rdi       # 0x3123
xorl %eax, %eax
callq 0x2050
leaq 0x34c(%rip), %rsi       # 0x315e
leaq -0x160(%rbp), %r12
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2070
leaq 0x33e(%rip), %rdi       # 0x316b
movq %r12, %rsi
xorl %eax, %eax
callq 0x2050
movl (%r13), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x25be
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 0x21c(%rip), %rdi       # 0x3086
callq 0x21b0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x2e4e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ea0
leaq 0x4b0(%rip), %rdi       # 0x333d
callq 0x22a0
leaq 0x4d6(%rip), %rdi       # 0x336f
callq 0x22a0
jmp 0x2f01
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
movl $0x0, (%rsi)
movq 0x18(%rbx), %rdi
callq 0x250c
movq %rax, %rbx
movzwl %r14w, %r14d
leaq 0x375(%rip), %rdi       # 0x3251
movl %r14d, %esi
xorl %eax, %eax
callq 0x2050
movl %r14d, %edi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x263b
testq %rbx, %rbx
je 0x2f01
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_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0xb0(%rsp), %r14
xorl %eax, %eax
movl %eax, (%r14)
movq %rax, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rax, 0x20(%r14)
leaq 0x2dc2(%rip), %rcx      # 0x5100
leaq 0x28(%rsp), %r15
movq %rcx, (%r15)
leaq 0x78(%rsp), %r12
movl %eax, (%r12)
callq 0x20a0
movq %rax, %rbx
movq %rax, 0x8(%r12)
leaq 0x2dae(%rip), %rsi      # 0x5111
leaq 0x30(%rsp), %rax
movq %rsi, (%rax)
leaq 0xa8(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %r15, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq %r12, 0x50(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x27de
cmpl $0x0, 0x78(%rsp)
setne %cl
xorb %cl, %al
je 0x24f6
leaq 0x2d55(%rip), %rsi      # 0x5111
leaq 0x2d52(%rip), %rdx      # 0x5115
leaq 0x38(%rsp), %rdi
callq 0x25a0
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
movl $0x1, %edx
callq 0x2640
movq 0xd0(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jne 0x24d7
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rdx
movq %r14, %rsi
callq 0x43b0
testb %al, %al
je 0x24d7
leaq 0x78(%rsp), %rdi
callq 0x275e
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x243e
callq 0x2120
leaq 0x48(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x2451
callq 0x2120
leaq 0x38(%rsp), %rdi
movq %r14, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x78(%rsp), %rdx
movl $0x0, (%rdx)
movq %rbx, 0x8(%rdx)
leaq 0xa8(%rsp), %rsi
callq 0x4446
cmpl $0x0, 0x78(%rsp)
setne %cl
xorb %cl, %al
je 0x2515
leaq 0x2ce6(%rip), %rsi      # 0x517e
leaq 0x38(%rsp), %rdi
callq 0x2070
testl %eax, %eax
jne 0x2534
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x24b9
callq 0x2120
leaq 0xa8(%rsp), %rdi
callq 0x275e
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x2c3d(%rip), %rdi      # 0x511b
leaq 0x2c77(%rip), %rsi      # 0x515c
leaq 0x2c87(%rip), %rcx      # 0x5173
movl $0x15, %edx
callq 0x20c0
leaq 0x2cd3(%rip), %rdi      # 0x51d0
leaq 0x2cd9(%rip), %rsi      # 0x51dd
leaq 0x2ce7(%rip), %rcx      # 0x51f2
movl $0xbd, %edx
callq 0x20c0
leaq 0x2cb4(%rip), %rdi      # 0x51d0
leaq 0x2cba(%rip), %rsi      # 0x51dd
leaq 0x2f84(%rip), %rcx      # 0x54ae
movl $0xe6, %edx
callq 0x20c0
leaq 0x2c51(%rip), %rdi      # 0x518c
leaq 0x2c1a(%rip), %rsi      # 0x515c
leaq 0x2c2a(%rip), %rcx      # 0x5173
movl $0x18, %edx
callq 0x20c0
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x258a
callq 0x2120
jmp 0x258a
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x275e
jmp 0x2579
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2616
jmp 0x258a
jmp 0x2587
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x275e
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x720d(%rip)            # 0xa194
movb $0x1, %bl
cmpl $0x0, 0x7478(%rip)      # 0xa408
jne 0x30ed
movq 0x74bb(%rip), %rax      # 0xa458
movq %rax, %rcx
subq 0x7491(%rip), %rcx      # 0xa438
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
movq 0x7486(%rip), %rdx      # 0xa440
subq 0x7487(%rip), %rdx      # 0xa448
sarq $0x3, %rdx
movabsq $-0x1111111111111111, %rax # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rdx
leaq (%rdx,%rcx,4), %rdx
movq 0x7452(%rip), %rsi      # 0xa430
subq 0x743b(%rip), %rsi      # 0xa420
sarq $0x3, %rsi
movabsq $0x1111111111111111, %rcx # imm = 0x1111111111111111
imulq %rcx, %rsi
cmpq %rsi, %rdx
jne 0x30ed
movq 0x74a1(%rip), %rdx      # 0xa4a8
movq %rdx, %rsi
subq 0x7477(%rip), %rsi      # 0xa488
sarq $0x3, %rsi
cmpq $0x1, %rdx
adcq $-0x1, %rsi
movq 0x746c(%rip), %rdx      # 0xa490
subq 0x746d(%rip), %rdx      # 0xa498
sarq $0x3, %rdx
imulq %rax, %rdx
movq 0x7446(%rip), %rdi      # 0xa480
subq 0x742f(%rip), %rdi      # 0xa470
leaq (%rdx,%rsi,4), %rdx
sarq $0x3, %rdi
imulq %rcx, %rdi
cmpq %rdi, %rdx
jne 0x30ed
movq 0x749b(%rip), %rdx      # 0xa4f8
movq %rdx, %rsi
subq 0x7471(%rip), %rsi      # 0xa4d8
sarq $0x3, %rsi
cmpq $0x1, %rdx
adcq $-0x1, %rsi
movq 0x7466(%rip), %rdx      # 0xa4e0
subq 0x7467(%rip), %rdx      # 0xa4e8
sarq $0x3, %rdx
imulq %rax, %rdx
movq 0x7440(%rip), %rax      # 0xa4d0
subq 0x7429(%rip), %rax      # 0xa4c0
leaq (%rdx,%rsi,4), %rdx
sarq $0x3, %rax
imulq %rcx, %rax
cmpq %rax, %rdx
jne 0x30ed
leaq 0x7451(%rip), %rdi      # 0xa500
callq 0x39a4
testq %rax, %rax
jne 0x30ed
callq 0x30f1
testb %al, %al
je 0x30ed
movq 0x732f(%rip), %rax      # 0xa3f8
cmpq 0x7320(%rip), %rax      # 0xa3f0
jne 0x30ed
leaq 0x7477(%rip), %rdi      # 0xa550
callq 0x39a4
testq %rax, %rax
jne 0x30ed
callq 0x3149
movl %eax, %ebx
xorb $0x1, %bl
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movl 0x7088(%rip), %ecx      # 0xa180
testq %rcx, %rcx
je 0x3135
movq 0x72dc(%rip), %rdx      # 0xa3e0
movq 0x72cd(%rip), %rdi      # 0xa3d8
subq %rdi, %rdx
sarq $0x7, %rdx
movb $0x1, %al
xorl %r8d, %r8d
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x313b
movzbl %al, %eax
cmpb $0x0, (%rdi)
cmovnel %r8d, %eax
incq %rsi
subq $-0x80, %rdi
cmpl %esi, %ecx
jne 0x3119
jmp 0x3137
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
leaq 0x41b4(%rip), %rdi      # 0x72f6
xorl %eax, %eax
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movl 0x702c(%rip), %ecx      # 0xa17c
testq %rcx, %rcx
je 0x319e
movq 0x7254(%rip), %rax      # 0xa3b0
movq 0x7245(%rip), %rdi      # 0xa3a8
subq %rdi, %rax
sarq $0x3, %rax
movabsq $-0x79435e50d79435e5, %rdx # imm = 0x86BCA1AF286BCA1B
imulq %rax, %rdx
movb $0x1, %al
xorl %r8d, %r8d
xorl %esi, %esi
cmpq %rsi, %rdx
jbe 0x31a4
movzbl %al, %eax
cmpb $0x0, (%rdi)
cmovnel %r8d, %eax
incq %rsi
addq $0x98, %rdi
cmpl %esi, %ecx
jne 0x317f
jmp 0x31a0
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
leaq 0x414b(%rip), %rdi      # 0x72f6
xorl %eax, %eax
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0x58ca(%rip), %rax      # 0xa3a8
movq (%rax), %rcx
movq 0x8(%rax), %rsi
leaq 0x5690(%rip), %rax      # 0xa17c
movl (%rax), %eax
subq %rcx, %rsi
je 0x4b1f
sarq $0x3, %rsi
movabsq $-0x79435e50d79435e5, %rdx # imm = 0x86BCA1AF286BCA1B
imulq %rsi, %rdx
movl $0x1, %esi
movzbl (%rcx), %edi
subl %edi, %eax
movl %esi, %edi
addq $0x98, %rcx
incl %esi
cmpq %rdi, %rdx
ja 0x4b0a
leaq 0x565e(%rip), %rcx      # 0xa184
cmpl (%rcx), %eax
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
leaq 0x50bd(%rip), %rax      # 0xa180
movl (%rax), %eax
testq %rax, %rax
je 0x50fc
leaq 0x5307(%rip), %rdx      # 0xa3d8
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x7, %rdx
xorl %esi, %esi
movl %eax, %edi
cmpq %rsi, %rdx
jbe 0x510c
movzbl (%rcx), %r8d
subl %r8d, %edi
incq %rsi
subq $-0x80, %rcx
cmpl %esi, %eax
jne 0x50e3
jmp 0x50fe
movl %eax, %edi
leaq 0x507f(%rip), %rax      # 0xa184
cmpl (%rax), %edi
setb %al
popq %rcx
retq
leaq 0x21e3(%rip), %rdi      # 0x72f6
xorl %eax, %eax
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl %edi, %esi
leaq 0x5045(%rip), %rcx      # 0xa3d8
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x7, %rdx
cmpq %rsi, %rdx
jbe 0x53b9
shlq $0x7, %rsi
movl 0x20(%rax,%rsi), %ecx
andl 0x28(%rax,%rsi), %ecx
cmpl $-0x1, %ecx
sete %al
retq
pushq %rax
leaq 0x1f35(%rip), %rdi      # 0x72f6
xorl %eax, %eax
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq 0x4ae9(%rip), %rax      # 0xa3f0
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
je 0x5940
sarq $0x7, %rdx
addq $0x78, %rcx
movl $0x1, %esi
xorl %eax, %eax
movl $0x1, %edi
cmpl $0x0, (%rcx)
movzbl %al, %eax
cmovel %esi, %eax
movl %edi, %r8d
subq $-0x80, %rcx
incl %edi
cmpq %r8, %rdx
ja 0x5927
jmp 0x5942
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13d
movq %rdx, %r15
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
callq 0x100230
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
callq 0xfa160
movq %rax, %rbx
movq %r14, %rdi
callq 0x100230
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11da50
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0xf0531
movq %r14, %rdi
movl %r13d, %esi
callq 0x1218b0
movq %rax, -0x30(%rbp)
testl %r13d, %r13d
movq %r15, -0x48(%rbp)
jle 0xf04f3
movq %r12, %rbx
movl %r13d, %r15d
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movq %r14, %rdi
callq 0x12a4c0
movq %rax, %r13
movq -0x48(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xf0560
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x10de60
incq %r12
cmpq %r12, %r15
jne 0xf04b4
leaq 0xdf3b3a(%rip), %rdx    # 0xee4034
movq %r14, %rdi
movq -0x38(%rbp), %rbx
movq %rbx, %rsi
movq -0x30(%rbp), %rcx
callq 0xf066e
leaq 0xdf3b25(%rip), %rdx    # 0xee4039
movq %r14, %rdi
movq -0x40(%rbp), %rsi
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf066e
callq 0xf7400
jmp 0xf0493
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x1, %esi
je 0x23e0
testl %esi, %esi
jne 0x23f3
leaq 0x3c81(%rip), %rsi      # 0x6058
leaq 0x3ca2(%rip), %rdx      # 0x6080
jmp 0x23ee
leaq 0x3c9a(%rip), %rsi      # 0x6081
leaq 0x3cab(%rip), %rdx      # 0x6099
movq %rbx, %rdi
jmp 0x2400
leaq 0x484a(%rip), %rdx      # 0x6c44
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4b98
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2465
movl $0x3, %ebx
xorl %edi, %edi
callq 0x246d
decl %ebx
jne 0x2419
movq 0x7b9d(%rip), %rax      # 0x9fc8
movq (%rax), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c28
movq %rbx, %rdi
callq 0x4c33
movq %rbx, %rdi
callq 0x246d
movq %rbx, %rdi
callq 0x4ca2
movl $0xa, %edi
callq 0x21d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rsi, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4c54
movq (%rbx), %rsi
leaq 0x2005(%rip), %rdi      # 0x6c4b
callq 0x2150
incl 0x8(%rbx)
movb $0x1, 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r14, %rdi
movl $0x20, %esi
callq 0x20b0
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_O1/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 0x4ce7
movq (%rbx), %rcx
leaq 0x1f6a(%rip), %rdi      # 0x6c42
movl $0x2, %esi
movl $0x1, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x4c54
movq (%rbx), %rdi
leaq 0x1f4c(%rip), %rsi      # 0x6c45
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_O1/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 0x1f1c(%rip), %rdi      # 0x6c43
callq 0x2150
movq %rbx, %rdi
callq 0x4c54
movq (%rbx), %rsi
leaq 0x1f02(%rip), %rdi      # 0x6c40
popq %rbx
jmp 0x2150
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d5f
movb $0x0, 0xc(%r15)
jmp 0x4d78
movq (%r15), %rcx
leaq 0x1ed9(%rip), %rdi      # 0x6c42
movl $0x2, %esi
movl $0x1, %edx
callq 0x2230
movq %r15, %rdi
callq 0x4c54
movq (%r15), %rdi
leaq 0x1ec4(%rip), %rsi      # 0x6c4e
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4db7
movb $0x0, 0xc(%r15)
jmp 0x4dd0
movq (%r15), %rcx
leaq 0x1e81(%rip), %rdi      # 0x6c42
movl $0x2, %esi
movl $0x1, %edx
callq 0x2230
movq %r15, %rdi
callq 0x4c54
movq (%r15), %rdi
leaq 0x1e77(%rip), %rsi      # 0x6c59
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e0f
movb $0x0, 0xc(%r15)
jmp 0x4e28
movq (%r15), %rcx
leaq 0x1e29(%rip), %rdi      # 0x6c42
movl $0x2, %esi
movl $0x1, %edx
callq 0x2230
movq %r15, %rdi
callq 0x4c54
movq (%r15), %rdi
leaq 0x1e29(%rip), %rsi      # 0x6c63
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e68
movb $0x0, 0xc(%r14)
jmp 0x4e81
movq (%r14), %rcx
leaq 0x1dd0(%rip), %rdi      # 0x6c42
movl $0x2, %esi
movl $0x1, %edx
callq 0x2230
movq %r14, %rdi
callq 0x4c54
movq (%r14), %rdi
leaq 0x1dda(%rip), %rsi      # 0x6c6d
movq %rbx, %rdx
movsd (%rsp), %xmm0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ed2
movq (%rbx), %rcx
leaq 0x1d7f(%rip), %rdi      # 0x6c42
movl $0x2, %esi
movl $0x1, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x4c54
movq (%rbx), %rdi
leaq 0x1d92(%rip), %rsi      # 0x6c76
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_O1/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 0x4f37
leaq 0x1d56(%rip), %rsi      # 0x6c80
xorl %eax, %eax
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0x1d40(%rip), %rsi      # 0x6c7e
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f6a
leaq 0x1d2a(%rip), %rsi      # 0x6c87
xorl %eax, %eax
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0x1d14(%rip), %rsi      # 0x6c85
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f9d
leaq 0x1cfd(%rip), %rsi      # 0x6c8d
xorl %eax, %eax
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0x1ce7(%rip), %rsi      # 0x6c8b
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4fcd
leaq 0x1cd3(%rip), %rsi      # 0x6c93
movb $0x1, %al
callq 0x21e0
movb $0x0, 0xc(%rbx)
popq %rbx
retq
leaq 0x1cbd(%rip), %rsi      # 0x6c91
movb $0x1, %al
popq %rbx
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ff3
movq (%rbx), %rsi
movl $0x2c, %edi
callq 0x21a0
movq (%rbx), %rsi
leaq 0x1c46(%rip), %rdi      # 0x6c43
callq 0x2150
movq %rbx, %rdi
callq 0x4c54
movq (%rbx), %rsi
leaq 0x1c37(%rip), %rdi      # 0x6c4b
callq 0x2150
incl 0x8(%rbx)
movb $0x1, 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x208, %rsp            # imm = 0x208
movq 0x2dc8(%rip), %rbx      # 0x3fd8
leaq 0xded(%rip), %rsi       # 0x2004
movl $0x22, %edx
movq %rbx, %rdi
callq 0x1070
leaq 0xdfc(%rip), %rsi       # 0x2027
leaq 0x8(%rsp), %rdi
movl $0x14, %edx
callq 0x1060
leaq 0xdf1(%rip), %rsi       # 0x2032
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x1070
movl $0xf, %ebp
leaq 0xdf5(%rip), %rbx       # 0x204f
leaq 0x8(%rsp), %r14
leaq 0xe2a(%rip), %r15       # 0x2090
movl $0xa, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
movl $0x5, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1080
decl %ebp
jne 0x1266
movq 0x2d47(%rip), %rdi      # 0x3fd8
leaq 0xdc2(%rip), %rsi       # 0x205a
movl $0x10, %edx
callq 0x1070
leaq 0x8(%rsp), %rdi
callq 0x1090
movq 0x2d25(%rip), %rdi      # 0x3fd8
leaq 0xdb1(%rip), %rsi       # 0x206b
movl $0x24, %edx
callq 0x1070
movq 0x2d05(%rip), %rax      # 0x3fd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x1040
leaq 0x100(%rsp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1308
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x10a0
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c0(%rbp), %rdi
callq 0xa3a0
leaq -0x1b0(%rbp), %rdi
leaq 0xb1ea(%rip), %rsi      # 0x16000
movl $0x1, %edx
callq 0xa6a0
movq (%r15), %r12
movq 0x8(%r15), %r14
subq %r12, %r14
leaq -0x1b0(%rbp), %r13
je 0xae84
movq %r13, -0x38(%rbp)
leaq 0xb1c4(%rip), %rax      # 0x16002
movq %rax, -0x30(%rbp)
addq $-0x4, %r14
sarq $0x2, %r14
testq %r14, %r14
jle 0xae6e
incq %r14
leaq -0x38(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xa990
addq $0x4, %r12
decq %r14
cmpq $0x1, %r14
jg 0xae56
movq 0x8(%r15), %rax
movl -0x4(%rax), %esi
leaq -0x1b0(%rbp), %r13
movq %r13, %rdi
callq 0xa950
leaq 0xb806(%rip), %rsi      # 0x16691
movl $0x1, %edx
movq %r13, %rdi
callq 0xa6a0
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0xa890
movq 0x120c2(%rip), %rsi     # 0x1cf70
leaq -0x1c0(%rbp), %rdi
callq 0xa3c0
leaq -0x140(%rbp), %rdi
callq 0xa1e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xaedf
jmp 0xaedf
movq %rax, %rbx
movq 0x12087(%rip), %rsi     # 0x1cf70
leaq -0x1c0(%rbp), %rdi
callq 0xa3c0
leaq -0x140(%rbp), %rdi
callq 0xa1e0
movq %rbx, %rdi
callq 0xa9a0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1c8(%rbp), %rdi
callq 0xa3a0
leaq -0x1b8(%rbp), %rdi
leaq 0xb0c0(%rip), %rsi      # 0x16000
movl $0x1, %edx
callq 0xa6a0
testq %r15, %r15
je 0xafb6
movq %rbx, -0x30(%rbp)
leaq -0x1b8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0xb09d(%rip), %rax      # 0x16002
movq %rax, -0x38(%rbp)
leaq -0x4(,%r15,4), %rbx
sarq $0x2, %rbx
testq %rbx, %rbx
jle 0xaf9c
incq %rbx
leaq -0x40(%rbp), %r13
movq %r14, %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xa990
addq $0x4, %r12
decq %rbx
cmpq $0x1, %rbx
jg 0xaf84
leaq (%r14,%r15,4), %rax
addq $-0x4, %rax
movl (%rax), %esi
leaq -0x1b8(%rbp), %rdi
callq 0xa950
movq -0x30(%rbp), %rbx
leaq 0xb6d4(%rip), %rsi      # 0x16691
movl $0x1, %edx
leaq -0x1b8(%rbp), %rdi
callq 0xa6a0
leaq -0x1b0(%rbp), %rsi
movq %rbx, %rdi
callq 0xa890
movq 0x11f8c(%rip), %rsi     # 0x1cf70
leaq -0x1c8(%rbp), %rdi
callq 0xa3c0
leaq -0x148(%rbp), %rdi
callq 0xa1e0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb013
movq %rax, %rbx
movq 0x11f53(%rip), %rsi     # 0x1cf70
leaq -0x1c8(%rbp), %rdi
callq 0xa3c0
leaq -0x148(%rbp), %rdi
callq 0xa1e0
movq %rbx, %rdi
callq 0xa9a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/pdx-cs-tutors[P]pdp/tests/base_test.cpp
// Function: BaseTestSuite::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int BaseTestSuite::run(std::string key) {
    int count = 0;
    if (key != "") {
        auto it = tests.find(key);
        if (it != tests.end()) {
            for (auto const& func: tests[key]) {
                setUp();
                func();
                tearDown();
                ++count;
            }
        }
    } else {
        for (auto const& test : tests) {
            for (auto const& func : test.second) {
                setUp();
                func();
                tearDown();
                ++count;
            }
        }
    }
    report();
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa9d2(%rip), %rsi      # 0x1603b
movq %r15, %rdi
callq 0xa170
leaq 0x10(%rbx), %r13
testl %eax, %eax
je 0xb6e4
leaq 0x8(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xa920
xorl %r14d, %r14d
cmpq %r13, %rax
je 0xb740
movq %r12, %rdi
movq %r15, %rsi
callq 0xaa60
movq (%rax), %r15
movq 0x8(%rax), %r12
cmpq %r12, %r15
je 0xb740
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
cmpq $0x0, 0x10(%r15)
je 0xb75b
movq %r15, %rdi
callq *0x18(%r15)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %r14d
addq $0x20, %r15
cmpq %r12, %r15
jne 0xb6b2
jmp 0xb740
movq 0x20(%rbx), %r15
xorl %r14d, %r14d
cmpq %r13, %r15
je 0xb740
movq %r13, -0x30(%rbp)
movq 0x40(%r15), %r12
movq 0x48(%r15), %r13
cmpq %r13, %r12
je 0xb72c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
cmpq $0x0, 0x10(%r12)
je 0xb75b
movq %r12, %rdi
callq *0x18(%r12)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
incl %r14d
addq $0x20, %r12
jmp 0xb6fc
movq %r15, %rdi
callq 0xa390
movq %rax, %r15
movq -0x30(%rbp), %r13
cmpq %r13, %rax
jne 0xb6f4
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa210