LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/utils.cpp
// Function: DoubleSpec::ReadOpt(int&, char**&)
int DoubleSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    argc--; argv++;
    if (argc == 0) {
      fprintf(stderr,"Need a parameter for %s\n", optstring);
      return -1;
    } else {
      // Should do some error checking here
      value = conversion * strtod(argv[0], NULL);
      return 1;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4270
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xab3e
addq $0x8, %r12
decl (%r15)
movq %r12, (%r14)
je 0xab4a
movsd 0x18(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq (%r12), %rdi
xorl %esi, %esi
callq 0x4170
mulsd (%rsp), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4454
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xab3e
nop
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/utils.cpp
// Function: CmdSpec::ReadOpt(int&, char**&)
int CmdSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    vector<string>cmd;
    // Skip the initial '-'
    assert(*argv[0] == '-');
    cmd.push_back(argv[0]+1);
    for (int i = 0; i < nargs; i++){
      argc--;argv++;
      if (argc == 0) {
	fprintf(stderr,"Need %d parameter for %s\n", nargs, optstring);
	return -1;
      } else {
	cmd.push_back(argv[0]);
      }
    }
    cmdlist.push_back(cmd);
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4270
xorl %ebp, %ebp
testl %eax, %eax
jne 0xac9e
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq (%r12), %rax
cmpb $0x2d, (%rax)
jne 0xacd5
movq (%r12), %r13
leaq 0x1(%r13), %r12
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r12, %rdi
callq 0x40d0
leaq (%rax,%r13), %rdx
incq %rdx
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xb11e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xaeb6
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xac17
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4230
cmpl $0x0, 0x10(%rbx)
jle 0xac7e
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rbp
decl (%r15)
setne %cl
movq (%r14), %rax
addq $0x8, %rax
movq %rax, (%r14)
testb %cl, %cl
je 0xacaf
movq (%rax), %rsi
movq %r12, %rdi
leaq 0xf(%rsp), %rdx
callq 0xad72
movq %rbp, %rdi
movq %r12, %rsi
callq 0xaeb6
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xac75
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4230
incl %r13d
cmpl 0x10(%rbx), %r13d
jl 0xac2a
movl $0x1, %ebp
leaq 0x85a6(%rip), %rdi      # 0x13230
leaq 0x30(%rsp), %rsi
callq 0xadb0
leaq 0x30(%rsp), %rdi
callq 0xaddc
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x832a(%rip), %rax      # 0x12fe0
movq (%rax), %rdi
movl 0x10(%rbx), %edx
movq 0x8(%rbx), %rcx
leaq 0x2c53(%rip), %rsi      # 0xd91a
xorl %eax, %eax
callq 0x4290
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0xac94
leaq 0x2bf6(%rip), %rdi      # 0xd8d2
leaq 0x2bff(%rip), %rsi      # 0xd8e2
leaq 0x2c02(%rip), %rcx      # 0xd8ec
movl $0x80, %edx
callq 0x4130
jmp 0xad1b
jmp 0xacfa
jmp 0xad1b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xad1e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x4230
jmp 0xad1e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xaddc
movq %rbx, %rdi
callq 0x4340
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: RgbSpec::ReadOpt(int&, char**&)
int RgbSpec::ReadOpt(int &argc, char** &argv) {
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    argc--; argv++;
    if (argc == 0) {
      fprintf(stderr,"Need a parameter for %s\n", optstring);
      return -1;
    } else {
      value = Rgb(argv[0]);
      return 1;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %r12
movq (%r12), %rdi
movq 0x8(%rbx), %rsi
callq 0x4270
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0xb775
addq $0x8, %r12
decl (%r15)
movq %r12, (%r14)
je 0xb781
movq (%r12), %rsi
leaq 0x5(%rsp), %r14
movq %r14, %rdi
callq 0xb4d0
movq 0x10(%rbx), %rax
movb 0x2(%r14), %cl
movb %cl, 0x2(%rax)
movzwl (%r14), %ecx
movw %cx, (%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x449d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xb775
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::Close()
void Image::Close()
{
  if (mmapdata != NULL) {
    if (munmap(mmapdata, mmapsize)) {
      syserror("Error unmapping input file");
    }
    close(mmapfd);
    mmapdata = NULL;
    mmapsize = 0;
    mmapfd = 0;
    data = NULL;
  } else if (data != NULL) {
    delete (data);
    data = NULL;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xb833
movq 0x20(%rbx), %rsi
callq 0x4120
testl %eax, %eax
je 0xb81e
leaq 0x2232(%rip), %rdi      # 0xda4b
callq 0xa912
movl 0x28(%rbx), %edi
callq 0x43a0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x1c(%rbx)
jmp 0xb84e
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xb84e
movl $0x1, %esi
callq 0x4230
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::Copy(Image const&)
void Image::Copy (const Image& image) {
  if (data == NULL) {
    width = image.width;
    height = image.height;
    data = new char[(long) width * height * 3];
    memcpy(data, image.data,(long) width * height * 3);
  } else {
    for (long y = 0; y < height && y < image.height; y++) {
      for (long x = 0; x < width && x < image.width; x++) {
	Rgb rgb;
	image.GetRgb(x,y,rgb);
	SetRgb(x,y,rgb);
      }
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0xb8f2
cmpq $0x0, 0x8(%r14)
jle 0xb8ec
cmpq $0x0, 0x8(%rbx)
jle 0xb8ec
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r14), %rdx
testq %rdx, %rdx
setg %sil
movq (%rbx), %r8
testq %r8, %r8
setg %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0xb8d9
movl $0x1, %esi
xorl %edi, %edi
imulq %rax, %r8
addq 0x10(%rbx), %r8
movzwl -0x1(%rsi,%r8), %r9d
movb 0x1(%rsi,%r8), %r8b
imulq %rax, %rdx
addq 0x10(%r14), %rdx
movw %r9w, -0x1(%rsi,%rdx)
movb %r8b, 0x1(%rsi,%rdx)
incq %rdi
movq (%r14), %rdx
cmpq %rdx, %rdi
jge 0xb8d9
addq $0x3, %rsi
movq (%rbx), %r8
cmpq %r8, %rdi
jl 0xb89c
incq %rcx
cmpq 0x8(%r14), %rcx
jge 0xb8ec
addq $0x3, %rax
cmpq 0x8(%rbx), %rcx
jl 0xb878
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rax
movq %rax, (%r14)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
imulq %rcx, %rax
leaq (%rax,%rax,2), %r15
movq %r15, %rdi
callq 0x4030
movq %rax, 0x10(%r14)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x41b0
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: GetLine(char*&, char*, char*, int)
static void GetLine (char* &dataptr, char* dataend, 
	      char* linebuffer, int length)
{
  do {
    int i = 0;
    if (dataptr == dataend) {
      error("Unexpected end of file\n");
    }
    while (dataptr < dataend && i <length-1) {
      char c = *dataptr;
      dataptr++;
      if (c == '\n') {
	break;
      }
      linebuffer[i] = c;
      i++;
    }
    linebuffer[i] = 0;
  } while (linebuffer[0] == '#' || linebuffer[0] == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x206d(%rip), %r12      # 0xdb9e
cmpq %r14, (%r15)
jne 0xbb3e
movq %r12, %rdi
callq 0xa8ec
xorl %eax, %eax
movq (%r15), %rdx
cmpq %r14, %rdx
jae 0xbb67
cmpl $0x7e, %eax
jg 0xbb67
movb (%rdx), %cl
incq %rdx
movq %rdx, (%r15)
cmpb $0xa, %cl
je 0xbb62
movslq %eax, %rdx
movb %cl, (%rbx,%rdx)
incl %eax
cmpb $0xa, %cl
jne 0xbb40
cltq
movb $0x0, (%rbx,%rax)
movzbl (%rbx), %eax
testl %eax, %eax
je 0xbb31
cmpl $0x23, %eax
je 0xbb31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::Write(char const*) const
void Image::Write (const char* filename) const
{
  if (mmapdata != NULL) {
    fprintf(stderr, "mmapped image - skipping WriteImage\n");
  } else {
    int fd = 1; // stdout
    char header[128];
    size_t datasize;
    if (filename != NULL) {
      fd = creat(filename, 0666);
      if (fd < 0) {
	syserror("Can't open output file");
      }
    }
#if defined O_BINARY
    // Ghastly hack to ensure CR/LF substitution not done, eg. on cygwin
    // Set the output type to binary, not text.
    setmode(fd,O_BINARY);
#endif
    sprintf(header, "P6\n%ld %ld\n255\n", width, height);
    if (write(fd, header, strlen(header)) < 0) {
      syserror("write failed");
    }
    datasize = (long) width * height * 3;
    char *dataptr = data;
    while (datasize > 0) {
      size_t MAXDATA = 64UL*1024*1024;
      ssize_t written = write(fd, dataptr, std::min(MAXDATA,datasize));
      fprintf(stderr,"%zd bytes written\n", written);
      if (written < 0) {
	syserror("write failed");
      }
      datasize -= written;
      dataptr += written;
    }
    if (filename != NULL) {
      close(fd);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpq $0x0, 0x18(%rdi)
jne 0xbc3b
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xbbca
movq %rbx, %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x4140
movl %eax, %ebp
testl %eax, %eax
jns 0xbbcf
leaq 0x1f56(%rip), %rdi      # 0xdb19
callq 0xa912
jmp 0xbbcf
movl $0x1, %ebp
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x1f53(%rip), %rsi      # 0xdb30
movq %rsp, %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x4060
movq %r15, %rdi
callq 0x40d0
movl %ebp, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40a0
testq %rax, %rax
jns 0xbc10
leaq 0x1f35(%rip), %rdi      # 0xdb40
callq 0xa912
movq (%r14), %rax
imulq 0x8(%r14), %rax
leaq (%rax,%rax,2), %rsi
testq %rsi, %rsi
jne 0xbc42
testq %rbx, %rbx
je 0xbc2d
movl %ebp, %edi
callq 0x43a0
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x44bb
jmp 0xbc2d
movq %r14, %rdi
movl %ebp, %edx
callq 0x44d7
jmp 0xbc21
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::AddGrid(double, double, Rgb const&)
void Image::AddGrid(double gridx, double gridy, const Rgb& color)
{
  double ystep = gridy * height/180.0;
  double xstep = gridx * width/360.0;
  // Quicker this way around with big images
  for (long y = 0; y < height; y++) {
    for (double xgrad = 0.0; ROUND(xgrad) < width; xgrad += xstep) {
      long x = long(ROUND(xgrad));
      SetRgb((long) y * width + x, color);
    }
  }
  for (double ygrad = 0.0; ROUND(ygrad) < height; ygrad += ystep) {
    long y = long(ROUND(ygrad));
    for (long x = 0; x < width; x++) {
      SetRgb((long) y * width + x, color);
    }
  }
#if 0
  long y = long(ROUND(height/2.0 - greenwichlat * height / pi));
  for (long x = 0; x < width; x++) {
    SetRgb((long) y * width + x, red);
  }
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movsd %xmm1, 0x10(%rsp)
movq %rdi, %r14
movq 0x8(%rdi), %r15
testq %r15, %r15
jle 0xbd13
xorps %xmm1, %xmm1
cvtsi2sdq (%r14), %xmm1
mulsd %xmm0, %xmm1
divsd 0x1d2a(%rip), %xmm1     # 0xd9b0
xorl %r12d, %r12d
movsd 0x17a7(%rip), %xmm2     # 0xd438
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rax
testq %rax, %rax
jle 0xbd0a
xorpd %xmm0, %xmm0
xorpd %xmm3, %xmm3
addsd %xmm1, %xmm3
movsd %xmm3, (%rsp)
cvttsd2si %xmm0, %rcx
imulq %r12, %rax
addq %rcx, %rax
movq 0x10(%r14), %rcx
addq %rax, %rcx
addq %rax, %rcx
movb (%rbx), %dl
movb %dl, (%rcx,%rax)
movb 0x1(%rbx), %dl
movb %dl, 0x1(%rcx,%rax)
movb 0x2(%rbx), %dl
movb %dl, 0x2(%rcx,%rax)
movapd %xmm3, %xmm0
addsd %xmm2, %xmm0
callq 0x4320
movsd (%rsp), %xmm3
movsd 0x1745(%rip), %xmm2     # 0xd438
movq (%r14), %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
ucomisd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm1
ja 0xbca7
incq %r12
cmpq 0x8(%r14), %r12
jl 0xbc97
cmpq $0x0, 0x8(%r14)
jle 0xbdbb
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
mulsd 0x10(%rsp), %xmm0
divsd 0x1c74(%rip), %xmm0     # 0xd9a8
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movsd %xmm1, (%rsp)
movq (%r14), %rax
testq %rax, %rax
jle 0xbd8f
cvttsd2si %xmm0, %rcx
leaq (%rcx,%rcx,2), %rcx
movl $0x2, %edx
xorl %esi, %esi
imulq %rcx, %rax
addq 0x10(%r14), %rax
movb (%rbx), %dil
movb %dil, -0x2(%rdx,%rax)
movb 0x1(%rbx), %dil
movb %dil, -0x1(%rdx,%rax)
movb 0x2(%rbx), %dil
movb %dil, (%rdx,%rax)
incq %rsi
movq (%r14), %rax
addq $0x3, %rdx
cmpq %rax, %rsi
jl 0xbd5f
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
addsd 0x1691(%rip), %xmm0     # 0xd438
callq 0x4320
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
ucomisd %xmm0, %xmm1
ja 0xbd47
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::MapX(MapFunction&, double, double)
void Image::MapX (MapFunction& f, double xoff, double yoff)
{
  double hh = height/2;
  double hw = width/2;
  double scale = f.Scale(width,height);
  //fprintf(stderr, "%f %f %f\n", xoff, yoff, scale);
  for (long y = 0; y < height; y++) {
    double y0 = (hh-y)*scale+yoff;
    f.InitY(y0);
    for (long x = 0; x < width; x++) {
      double x0 = (x-hw)*scale+xoff;
      //fprintf (stderr, "%d %d %f %f\n", x,y,x0,y0);
      SetRgb((long) y*width+x, f(x0,y0));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %r15
movq 0x8(%rdi), %r12
movq (%rsi), %rax
movq %rsi, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *(%rax)
cmpq $0x0, 0x8(%r14)
jle 0xbf0a
movapd %xmm0, %xmm1
movq %r12, %rax
shrq $0x3f, %rax
addq %r12, %rax
sarq %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r15, %rax
shrq $0x3f, %rax
addq %r15, %rax
sarq %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
xorl %eax, %eax
movsd %xmm1, (%rsp)
movq %rax, 0x28(%rsp)
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
movsd 0x18(%rsp), %xmm0
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
addsd 0x20(%rsp), %xmm0
movq (%r13), %rax
movq %r13, %rdi
movsd %xmm0, 0x30(%rsp)
callq *0x8(%rax)
movq (%r14), %rbp
testq %rbp, %rbp
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
jle 0xbeef
movl $0x2, %ebx
xorl %r12d, %r12d
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
subsd %xmm2, %xmm0
mulsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movq (%r13), %rax
movq %r13, %rdi
movsd 0x30(%rsp), %xmm1
callq *0x10(%rax)
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
imulq %r15, %rbp
addq 0x10(%r14), %rbp
movb %al, -0x2(%rbx,%rbp)
movb %ah, -0x1(%rbx,%rbp)
shrl $0x10, %eax
movb %al, (%rbx,%rbp)
incq %r12
movq (%r14), %rbp
addq $0x3, %rbx
cmpq %rbp, %r12
jl 0xbe99
movq 0x28(%rsp), %rax
incq %rax
addq $0x3, %r15
cmpq 0x8(%r14), %rax
movsd (%rsp), %xmm1
jl 0xbe4c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::PlotPoint(double, double, int, Rgb const&)
void Image::PlotPoint(double x, double y, int r, const Rgb &rgb)
{
  //fprintf(stderr,"%g %g %g\n",x,y,r);
  for (int j = -r; j <= r; j ++) {
    for (int i = -r; i <= r; i++) {
      CheckSetRgb(long(ROUND(x+i)),long(ROUND(y+j)),rgb);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rsi, 0x10(%rsp)
testl %esi, %esi
js 0xc30f
movq %rdx, %rbx
movq %rdi, %r15
movq 0x10(%rsp), %rax
movl %eax, %ecx
negl %ecx
leal 0x1(,%rax,2), %eax
movl %eax, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movl %ecx, %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
addsd 0x18(%rsp), %xmm0
addsd 0x11b0(%rip), %xmm0     # 0xd438
callq 0x4320
cvttsd2si %xmm0, %r12
movl 0x8(%rsp), %r14d
movl 0xc(%rsp), %ebp
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
addsd 0x20(%rsp), %xmm0
addsd 0x1188(%rip), %xmm0     # 0xd438
callq 0x4320
cvttsd2si %xmm0, %rcx
testq %rcx, %rcx
js 0xc2f6
testq %r12, %r12
js 0xc2f6
movq (%r15), %rax
cmpq %rcx, %rax
jle 0xc2f6
cmpq %r12, 0x8(%r15)
jle 0xc2f6
imulq %r12, %rax
addq %rcx, %rax
movq 0x10(%r15), %rcx
addq %rax, %rcx
addq %rax, %rcx
movb (%rbx), %dl
movb %dl, (%rcx,%rax)
movb 0x1(%rbx), %dl
movb %dl, 0x1(%rcx,%rax)
movb 0x2(%rbx), %dl
movb %dl, 0x2(%rcx,%rax)
incl %ebp
decl %r14d
jne 0xc29b
leal 0x1(%r13), %eax
cmpl 0x10(%rsp), %r13d
movl %eax, %r13d
jne 0xc272
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/matthewarcus[P]mmps/image.cpp
// Function: Image::PlotLine(double, double, LinePlotter const&, Rgb const&, int)
void Image::PlotLine(double t0, double t1, 
		     const LinePlotter& lineplotter,
		     const Rgb& color,
		     int numinitialpoints)
{
  double inc = (t1-t0)/numinitialpoints;
  for (int i = 0; i < numinitialpoints; i++) {
    PlotLineAux(t0 + i * inc, t0 + (i+1) * inc,
		lineplotter, color, 10);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
testl %ecx, %ecx
jle 0xc3c9
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
subsd 0x8(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
negl %ebx
xorpd %xmm1, %xmm1
movl $0x1, %r13d
movapd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm2
mulsd %xmm2, %xmm0
movsd 0x8(%rsp), %xmm3
addsd %xmm3, %xmm0
addsd 0xcc1(%rip), %xmm1      # 0xd048
movsd %xmm1, 0x18(%rsp)
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0xa, %ecx
callq 0xc3d8
movsd 0x18(%rsp), %xmm1
leal (%rbx,%r13), %eax
incl %eax
movl %r13d, %ecx
incl %ecx
movl %ecx, %r13d
cmpl $0x1, %eax
jne 0xc367
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shutow[P]shared_mutex/./test_util.h
// Function: rand_wait()
inline void rand_wait()
{
	//return; // no wait

	static std::random_device rd;
	static std::mt19937 gen(rd());
	static std::uniform_int_distribution<> dis(0, 1);

	std::this_thread::sleep_for(std::chrono::milliseconds(dis(gen)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb 0x6894(%rip), %al       # 0x9500
testb %al, %al
je 0x2cfb
movb 0x7c16(%rip), %al       # 0xa890
testb %al, %al
je 0x2d49
movb 0x7c18(%rip), %al       # 0xa8a0
testb %al, %al
je 0x2dbe
leaq 0x6871(%rip), %rsi      # 0x9508
leaq 0x7bfa(%rip), %rdi      # 0xa898
movq %rdi, %rdx
callq 0x3126
testl %eax, %eax
jle 0x2cf2
movl %eax, %ecx
movabsq $0x4189374bc6a7f0, %rdx # imm = 0x4189374BC6A7F0
movq %rcx, %rax
mulq %rdx
imulq $-0x3e8, %rdx, %rax     # imm = 0xFC18
addq %rcx, %rax
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
leaq -0x20(%rbp), %rbx
movq %rdx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x2cf2
callq 0x2040
cmpl $0x4, (%rax)
je 0x2cd8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x67fe(%rip), %rbx      # 0x9500
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2c74
leaq 0x545f(%rip), %rdi      # 0x8178
callq 0x3008
leaq 0x353(%rip), %rdi       # 0x3078
leaq 0x544c(%rip), %rsi      # 0x8178
leaq 0x542d(%rip), %rdx      # 0x8160
callq 0x2160
leaq 0x67c1(%rip), %rdi      # 0x9500
callq 0x2110
jmp 0x2c74
leaq 0x7b40(%rip), %rbx      # 0xa890
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2c82
leaq 0x5411(%rip), %rdi      # 0x8178
callq 0x21f0
movl %eax, %eax
movq %rax, 0x6793(%rip)      # 0x9508
movl $0x1, %ecx
leaq 0x6787(%rip), %rdx      # 0x9508
movq %rax, %rsi
shrq $0x1e, %rsi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdx,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2d81
movq $0x270, 0x7adb(%rip) # imm = 0x270
leaq 0x7adc(%rip), %rdi      # 0xa890
callq 0x2110
jmp 0x2c82
callq 0x22c0
jmp 0x2c90
jmp 0x2dca
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/shutow[P]shared_mutex/./test_util.h
// Function: my_rand()
inline int my_rand()
{
	static std::random_device rd;
	static std::mt19937 gen(rd());
	static std::uniform_int_distribution<> dis(1, 1000000000);
	return dis(gen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb 0x8e46(%rip), %al       # 0xbc30
testb %al, %al
je 0x2e20
movb 0xa1cc(%rip), %al       # 0xcfc0
testb %al, %al
je 0x2e67
movb 0xa1d2(%rip), %al       # 0xcfd0
testb %al, %al
je 0x2edc
leaq 0x8e2b(%rip), %rsi      # 0xbc38
leaq 0xa1b4(%rip), %rdi      # 0xcfc8
movq %rdi, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x3126
leaq 0x8e09(%rip), %rbx      # 0xbc30
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2dee
leaq 0x7a6e(%rip), %rdi      # 0xa8a8
callq 0x3008
leaq 0x232(%rip), %rdi       # 0x3078
leaq 0x7a5b(%rip), %rsi      # 0xa8a8
leaq 0x530c(%rip), %rdx      # 0x8160
callq 0x2160
leaq 0x8dd0(%rip), %rdi      # 0xbc30
callq 0x2110
jmp 0x2dee
leaq 0xa152(%rip), %rbx      # 0xcfc0
movq %rbx, %rdi
callq 0x22a0
testl %eax, %eax
je 0x2df8
leaq 0x7a23(%rip), %rdi      # 0xa8a8
callq 0x21f0
movl %eax, %eax
movq %rax, 0x8da5(%rip)      # 0xbc38
movl $0x1, %ecx
leaq 0x8d99(%rip), %rdx      # 0xbc38
movq %rax, %rsi
shrq $0x1e, %rsi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, (%rdx,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2e9f
movq $0x270, 0xa0ed(%rip) # imm = 0x270
leaq 0xa0ee(%rip), %rdi      # 0xcfc0
callq 0x2110
jmp 0x2df8
callq 0x22f4
jmp 0x2e06
jmp 0x2ee8
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::delay()
void delay()
		{
			if (m_strategy == yield)
				std::this_thread::yield();
			else if (m_strategy == wait)
				std::this_thread::sleep_for(std::chrono::duration<uint64_t, std::micro>(m_wait_microseconds));
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x2f59
testl %eax, %eax
jne 0x2fac
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0x2210
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x2fac
movabsq $0x431bde82d7b634db, %rdx # imm = 0x431BDE82D7B634DB
movq %rcx, %rax
mulq %rdx
shrq $0x12, %rdx
imulq $-0xf4240, %rdx, %rax   # imm = 0xFFF0BDC0
addq %rcx, %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
leaq -0x18(%rbp), %rbx
movq %rdx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x20a0
cmpl $-0x1, %eax
jne 0x2fac
callq 0x2040
cmpl $0x4, (%rax)
je 0x2f92
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::unlock_shared_and_lock()
void unlock_shared_and_lock()
		{
			bool expected = false;
			if (m_exclusive.compare_exchange_weak(expected, true, std::memory_order_acq_rel, std::memory_order_acquire))
			{
				m_counter.fetch_sub(1, std::memory_order_acq_rel);
				while (m_counter.load(std::memory_order_acquire) > 0) delay();
			}
			else // if some thread is claimed m_exclusive already and waits for m_counter == 0
			{
				int64_t num = m_priority_exclusive.fetch_add(1, std::memory_order_acq_rel) + 1;
				while (m_counter.load(std::memory_order_acquire) > num) delay();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %cl
xorl %eax, %eax
lock
cmpxchgb %cl, 0x18(%rdi)
jne 0x2fe1
lock
decq 0x20(%rbx)
movq 0x20(%rbx), %rax
testq %rax, %rax
jle 0x3003
movq %rbx, %rdi
callq 0x2f3a
jmp 0x2fce
movl $0x1, %r14d
lock
xaddq %r14, 0x10(%rbx)
incq %r14
movq 0x20(%rbx), %rax
cmpq %r14, %rax
jle 0x3003
movq %rbx, %rdi
callq 0x2f3a
jmp 0x2ff0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::lock()
void lock()
		{
			bool expected = false;
			while (!m_exclusive.compare_exchange_weak(expected, true, std::memory_order_acq_rel, std::memory_order_acquire))
			{
				delay();
				expected = false;
			}
			while (m_counter.load(std::memory_order_acquire) > 0) delay();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %r14b
xorl %eax, %eax
lock
cmpxchgb %r14b, 0x18(%rdi)
je 0x33b1
movq %rbx, %rdi
callq 0x2f3a
xorl %eax, %eax
lock
cmpxchgb %r14b, 0x18(%rbx)
jne 0x3395
jmp 0x33b1
movq %rbx, %rdi
callq 0x2f3a
movq 0x20(%rbx), %rax
testq %rax, %rax
jg 0x33a9
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/pgrouchy[P]NoiseWorld/master.cpp
// Function: term_trap(int)
void term_trap(int sig)
{
    stringstream final_clean_1;
    final_clean_1 << "killall EMM_island";
    system(final_clean_1.str().c_str());
    cout << "Islands submerged..." << endl;
    stringstream final_clean_2;
    final_clean_2 << "rm -rf /dev/shm/*";
    system(final_clean_2.str().c_str());
    cout << "Term was trapped. RAMdisk cleaned successfully (hopefully?).\n";
    exit(0);
}

// Assembly:
pushq %rbx
subq $0x330, %rsp            # imm = 0x330
leaq 0x1a8(%rsp), %rdi
callq 0x2100
leaq 0x1b8(%rsp), %rdi
leaq 0x7b60(%rip), %rsi      # 0xa070
movl $0x12, %edx
callq 0x2230
leaq 0x1c0(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x22f0
movq 0x20(%rsp), %rdi
callq 0x2190
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2551
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2210
movq 0xba80(%rip), %rbx      # 0xdfd8
leaq 0x7b24(%rip), %rsi      # 0xa083
movl $0x14, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq 0xba4e(%rip), %rdi      # 0xdfd8
callq 0x2040
movq %rax, %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x2100
leaq 0x30(%rsp), %rdi
leaq 0x7aeb(%rip), %rsi      # 0xa098
movl $0x11, %edx
callq 0x2230
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0x22f0
movq (%rsp), %rdi
callq 0x2190
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2210
movq 0xb9e9(%rip), %rdi      # 0xdfd8
leaq 0x7ab4(%rip), %rsi      # 0xa0aa
callq 0x21e0
xorl %edi, %edi
callq 0x2260
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2627
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x2627
jmp 0x2624
movq %rax, %rbx
movq 0xb98a(%rip), %rsi      # 0xdfb8
leaq 0x20(%rsp), %rdi
callq 0x2130
leaq 0xa0(%rsp), %rdi
callq 0x2090
jmp 0x266e
jmp 0x266b
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x266e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2210
jmp 0x266e
jmp 0x266b
movq %rax, %rbx
movq 0xb943(%rip), %rsi      # 0xdfb8
leaq 0x1a8(%rsp), %rdi
callq 0x2130
leaq 0x228(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O1/gkalsi[P]barbecue/test.cc
// Function: consumer(BoundedBlockingQueue<int>*, int)
void consumer(BoundedBlockingQueue<int>* bbq, const int n) {
	for (int i = 0; i < n; ++i) {
		auto val = bbq->pop();
		if (results.find(val) == results.end()) {
			results[val] = 1;
		} else {
			results[val]++;
		}
	}
}

// Assembly:
testl %esi, %esi
jle 0x2705
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x3ac2(%rip), %r13      # 0x6148
leaq 0x3ab3(%rip), %r15      # 0x6140
leaq 0x4(%rsp), %r12
movq %r14, %rdi
callq 0x28d6
movl %eax, 0x4(%rsp)
movq 0x3aab(%rip), %rdx      # 0x6150
movq %r13, %rcx
testq %rdx, %rdx
je 0x26c7
movq %r13, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setl %sil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x26b0
cmpq %r13, %rcx
je 0x26d1
cmpl 0x20(%rcx), %eax
jge 0x26e4
movq %r15, %rdi
movq %r12, %rsi
callq 0x294a
movl $0x1, (%rax)
jmp 0x26f1
movq %r15, %rdi
movq %r12, %rsi
callq 0x294a
incl (%rax)
incl %ebp
cmpl %ebx, %ebp
jne 0x2692
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gkalsi[P]barbecue/./bbq.h
// Function: BoundedBlockingQueue<int>::pop()
T pop() {
    std::unique_lock<std::mutex> lock(mutex_);
    while (queue_.empty()) {
      cv_.wait(lock);
    }
    auto result = queue_.front();
    queue_.pop();
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x50(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x2e1c
movb $0x1, 0x8(%r14)
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
jne 0x2929
leaq 0x78(%rbx), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2060
movq 0x10(%rbx), %rax
cmpq %rax, 0x30(%rbx)
je 0x2914
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x3078
leaq 0x8(%rsp), %rdi
callq 0x2e06
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kmichel[P]bf0x/main.cpp
// Function: main
int main(int, char*[]) {
    auto multiply = bf0x::interpreter<bf0x::bstack<bf0x::interpreter>,
         ',','>',',','>','+','+','+','+','+','+','+','+','[','<','-','-',
         '-','-','-','-','<','-','-','-','-','-','-','>','>','-',']','<',
         '<','[','>','[','>','+','>','+','<','<','-',']','>','>','[',
         '<','<','+','>','>','-',']','<','<','<','-',']','>','>','>',
         '+','+','+','+','+','+','[','<','+','+','+','+',
         '+','+','+','+','>','-',']',',','<','.','>','.'>();

    bf0x::state st;
    multiply.exec(st);

    std::cout << std::endl;
    return 0;
}

// Assembly:
pushq %rbx
subq $0x10010, %rsp          # imm = 0x10010
leaq 0xc(%rsp), %rbx
movl $0x10004, %edx          # imm = 0x10004
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1040
movq %rbx, %rdi
callq 0x122a
movq 0x2dd9(%rip), %rbx      # 0x3fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1070
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x10010, %rsp          # imm = 0x10010
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kmichel[P]bf0x/./bf0x.hpp
// Function: bf0x::interpreter<bf0x::bstack<bf0x::loop_interpreter, bf0x::interpreter>, (char)91, (char)62, (char)43, (char)62, (char)43, (char)60, (char)60, (char)45, (char)93, (char)62, (char)62, (char)91, (char)60, (char)60, (char)43, (char)62, (char)62, (char)45, (char)93, (char)60, (char)60, (char)60, (char)45, (char)93, (char)62, (char)62, (char)62, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)91, (char)60, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)43, (char)62, (char)45, (char)93, (char)44, (char)60, (char)46, (char)62, (char)46>::exec(bf0x::state&)
static void exec(state& st) {
        BF0X_TRACE("[\n");
        while (st.data[st.pos]) {
            for (int i=0; i<bstack::size; ++i) BF0X_TRACE("  ");

            top<typename bstack::template push<loop_interpreter>::type
                , tail...>::type::exec(st);
        }
        for (int i=0; i<bstack::size-1; ++i) BF0X_TRACE("  ");
        BF0X_TRACE("]");

        top<typename bstack::template push<tail_interpreter>::type
            , tail...>::type::exec(st);
    }

// Assembly:
movl 0x10000(%rdi), %eax
cmpb $0x0, (%rdi,%rax)
je 0x1424
incl %eax
movl %eax, 0x10000(%rdi)
incb (%rdi,%rax)
movl 0x10000(%rdi), %eax
incl %eax
movl %eax, 0x10000(%rdi)
incb (%rdi,%rax)
movl 0x10000(%rdi), %eax
addl $-0x2, %eax
movl %eax, 0x10000(%rdi)
decb (%rdi,%rax)
jmp 0x13e8
addl $0x2, %eax
movl %eax, 0x10000(%rdi)
jmp 0x1432
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/swxJsonAdvancedTest_modify.cpp
// Function: main
int main()
{
	advancedSetTest();
	advancedAssignTest();
	advancedPushTest();
	advancedMergeTest();
	advancedPathPushTest();
	advancedPathAddTest();
	advancedPathMergeTest();
	specialMergeAndPushTest();

	return 0;
}

// Assembly:
pushq %rax
callq 0x13e8c
callq 0x1483f
callq 0x14e52
callq 0x1545d
callq 0x15d8e
callq 0x16914
callq 0x17782
callq 0x186b8
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, 4ul>(std::array<int, 4ul> const&)
bool push(const std::array<T, N>& arr)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(arr);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x19dc5
cmpl $0x8, %eax
jne 0x19dc3
movq %r14, %rdi
callq 0x24ca4
jmp 0x19dc5
xorl %ebx, %ebx
testb %bl, %bl
je 0x19e60
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x198b0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x19e35
movq 0x1e1a9(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x19e31
incl 0x8(%rax)
jmp 0x19e35
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19e51
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x19e60
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19e85
callq 0x21a22
jmp 0x19e85
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x19e94
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::allocator<int>>(std::deque<int, std::allocator<int>> const&)
bool push(const std::deque<T, Alloc>& deq)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(deq);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x19ec7
cmpl $0x8, %eax
jne 0x19ec5
movq %r14, %rdi
callq 0x24ca4
jmp 0x19ec7
xorl %ebx, %ebx
testb %bl, %bl
je 0x19f62
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x198e0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x19f37
movq 0x1e0a7(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x19f33
incl 0x8(%rax)
jmp 0x19f37
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19f53
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x19f62
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19f87
callq 0x21a22
jmp 0x19f87
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x19f96
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<std::vector, bool, std::allocator<bool>>(std::vector<bool, std::allocator<bool>> const&)
bool push(const Container<T, Alloc>& container)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(container);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x19fc9
cmpl $0x8, %eax
jne 0x19fc7
movq %r14, %rdi
callq 0x24ca4
jmp 0x19fc9
xorl %ebx, %ebx
testb %bl, %bl
je 0x1a064
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x1993e
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1a039
movq 0x1dfa5(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x1a035
incl 0x8(%rax)
jmp 0x1a039
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a055
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a064
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a089
callq 0x21a22
jmp 0x1a089
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a098
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::less<int>, std::allocator<int>>(std::set<int, std::less<int>, std::allocator<int>> const&)
bool push(const std::set<T, Compare, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(collections);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x1a4d3
cmpl $0x8, %eax
jne 0x1a4d1
movq %r14, %rdi
callq 0x24ca4
jmp 0x1a4d3
xorl %ebx, %ebx
testb %bl, %bl
je 0x1a56e
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x19a64
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1a543
movq 0x1da9b(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x1a53f
incl 0x8(%rax)
jmp 0x1a543
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a55f
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a56e
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a593
callq 0x21a22
jmp 0x1a593
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a5a2
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::hash<int>, std::equal_to<int>, std::allocator<int>>(std::unordered_set<int, std::hash<int>, std::equal_to<int>, std::allocator<int>> const&)
bool push(const std::unordered_set<Key, Hash, Pred, Alloc>& collections)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setArray(collections);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x1a5d5
cmpl $0x8, %eax
jne 0x1a5d3
movq %r14, %rdi
callq 0x24ca4
jmp 0x1a5d5
xorl %ebx, %ebx
testb %bl, %bl
je 0x1a670
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x19aa4
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1a645
movq 0x1d999(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x1a641
incl 0x8(%rax)
jmp 0x1a645
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a661
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a670
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a695
callq 0x21a22
jmp 0x1a695
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a6a4
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, bool>>> const&)
bool push(const std::map<std::string, T, Compare, Alloc>& theMap)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setDict(theMap);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x1a6d7
cmpl $0x8, %eax
jne 0x1a6d5
movq %r14, %rdi
callq 0x24ca4
jmp 0x1a6d7
xorl %ebx, %ebx
testb %bl, %bl
je 0x1a772
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x19ad6
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1a747
movq 0x1d897(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x1a743
incl 0x8(%rax)
jmp 0x1a747
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a763
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a772
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a797
callq 0x21a22
jmp 0x1a797
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a7a6
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::push<int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&)
bool push(const std::unordered_map<std::string, T, Hash, Pred, Alloc>& theMap)
	{
		bool res = canBeArray();
		if (res)
		{
			JsonPtr node(new Json());
			node->setDict(theMap);
			pushNode(node);
		}
		return res;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bl
cmpl $0x1, %eax
je 0x1aadf
cmpl $0x8, %eax
jne 0x1aadd
movq %r14, %rdi
callq 0x24ca4
jmp 0x1aadf
xorl %ebx, %ebx
testb %bl, %bl
je 0x1ab7a
movl $0x10, %edi
callq 0x13210
movl $0x8, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %rax, %rsi
callq 0x21950
movq -0x8(%r12), %rdi
movq %r15, %rsi
callq 0x19c56
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1ab4f
movq 0x1d48f(%rip), %rcx     # 0x37fd0
cmpb $0x0, (%rcx)
je 0x1ab4b
incl 0x8(%rax)
jmp 0x1ab4f
lock
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x24cfe
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab6b
callq 0x21a22
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab7a
callq 0x21a22
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab9f
callq 0x21a22
jmp 0x1ab9f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1abae
callq 0x21a22
movq %rbx, %rdi
callq 0x13380
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, 4ul>(std::array<int, 4ul> const&)
bool merge(const std::array<T, N>& arr)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: arr)
				push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1ac6a
cmpl $0x8, %eax
jne 0x1ac68
movq %r14, %rdi
callq 0x24ca4
jmp 0x1ac6a
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x1ac88
xorl %r15d, %r15d
movslq (%rbx,%r15), %rsi
movq %r14, %rdi
callq 0x2186c
addq $0x4, %r15
cmpq $0x10, %r15
jne 0x1ac72
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<int, std::allocator<int>>(std::deque<int, std::allocator<int>> const&)
bool merge(const std::deque<T, Alloc>& deq)
	{
		bool res = canBeArray();
		if (res)
		{
			for (auto& data: deq)
			 push(data);
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1acc2
cmpl $0x8, %eax
jne 0x1acc0
movq %rbx, %rdi
callq 0x24ca4
jmp 0x1acc2
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x1ad06
movq 0x10(%r14), %r12
movq 0x30(%r14), %r15
cmpq %r15, %r12
je 0x1ad06
movq 0x20(%r14), %r13
movq 0x28(%r14), %r14
movslq (%r12), %rsi
movq %rbx, %rdi
callq 0x2186c
addq $0x4, %r12
cmpq %r13, %r12
jne 0x1ad01
movq 0x8(%r14), %r12
addq $0x8, %r14
leaq 0x200(%r12), %r13
cmpq %r15, %r12
jne 0x1acdc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/swxlion[P]swxJson/tests/../src/swxJson.Enhancement.inc.h
// Function: bool swxJson::Json::merge<std::allocator<bool>>(std::vector<bool, std::allocator<bool>> const&)
bool merge(const std::vector<bool, Alloc>& container)
	{
		bool res = canBeArray();
		if (res)
		{
			for (size_t i = 0; i < container.size(); i++)
				push(container.at(i));
		}
		return res;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movb $0x1, %bpl
cmpl $0x1, %eax
je 0x1ad40
cmpl $0x8, %eax
jne 0x1ad3e
movq %r14, %rdi
callq 0x24ca4
jmp 0x1ad40
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x1ad87
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %ecx
subq (%rbx), %rax
shlq $0x3, %rax
addq %rcx, %rax
je 0x1ad87
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2335c
movzbl %al, %esi
movq %r14, %rdi
callq 0x233bc
incq %r15
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %ecx
subq (%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %rax, %r15
jb 0x1ad5b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq