LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: matthewarcus[P]mmps/equations.cpp
// Function: sunrise(double, double)
double sunrise (double date, double phi)
{
  double t0 = 0;
  double t1 = pi;
  double epsilon = 1e-6;
  while (t1 - t0 > epsilon) {
    double t = (t1 + t0) / 2.0;
    double h = sunaltitude(date + t/daysinyear, phi, t);
    //printf ("%f %f %f %f\n", t0, t1, t, h);
    if (h < sunriseangle) {
      t0 = t;
    } else {
      t1 = t;
    }
  }
  return t0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x5236(%rip), %xmm0     # 0x15008
movsd %xmm0, -0x20(%rbp)
movsd 0x5659(%rip), %xmm0     # 0x15438
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0xfe6c
movsd -0x20(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd 0x5619(%rip), %xmm1     # 0x15420
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x8(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd 0x59c6(%rip), %xmm2     # 0x157e8
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
callq 0xfc80
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm1
movsd 0xd4b5(%rip), %xmm0     # 0x1d300
ucomisd %xmm1, %xmm0
jbe 0xfe5d
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xfe67
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xfde4
movsd -0x18(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: matthewarcus[P]mmps/utils.cpp
// Function: OptSpec::ReadOpts(int&, char**&, OptSpec**)
int OptSpec::ReadOpts (int &argc, char** &argv, OptSpec* optspecs[])
{
  int i = 0;
  while (optspecs[i] != NULL) {
    int result = optspecs[i]->ReadOpt(argc, argv);
    if (result != 0) {
      return result;
    }
    i++;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xffaf
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *(%rax)
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0xffa4
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xffb6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xff6b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: matthewarcus[P]mmps/utils.cpp
// Function: BoolSpec::ReadOpt(int&, char**&)
int BoolSpec::ReadOpt(int &argc, char** &argv) {
  (void(argc));
  if (strcmp(argv[0], optstring) != 0) {
    return 0;
  } else {
    value = true;
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
callq 0x5350
cmpl $0x0, %eax
je 0x1004d
movl $0x0, -0x4(%rbp)
jmp 0x1005f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x1, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: matthewarcus[P]mmps/utils.cpp
// Function: StringSpec::ReadOpt(int&, char**&)
int StringSpec::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 = argv[0];
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
callq 0x5350
cmpl $0x0, %eax
je 0x100fd
movl $0x0, -0x4(%rbp)
jmp 0x10164
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x10148
movq -0x28(%rbp), %rax
movq 0xceb6(%rip), %rcx      # 0x1cfe0
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
leaq 0x56ef(%rip), %rsi      # 0x15827
movb $0x0, %al
callq 0x5370
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10164
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
movq 0x10(%rax), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: matthewarcus[P]mmps/utils.cpp
// Function: IntSpec::ReadOpt(int&, char**&)
int IntSpec::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 = strtol(argv[0],NULL,0);
      return 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
callq 0x5350
cmpl $0x0, %eax
je 0x101fd
movl $0x0, -0x4(%rbp)
jmp 0x10271
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x10248
movq -0x28(%rbp), %rax
movq 0xcdb6(%rip), %rcx      # 0x1cfe0
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
leaq 0x55ef(%rip), %rsi      # 0x15827
movb $0x0, %al
callq 0x5370
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10271
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x5360
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
callq 0x5350
cmpl $0x0, %eax
je 0x10320
movl $0x0, -0x4(%rbp)
jmp 0x103ab
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1036b
movq -0x28(%rbp), %rax
movq 0xcc93(%rip), %rcx      # 0x1cfe0
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
leaq 0x54cc(%rip), %rsi      # 0x15827
movb $0x0, %al
callq 0x5370
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x103ab
movq -0x28(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x51e0
movq -0x28(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
mulsd %xmm1, %xmm0
movq 0x10(%rax), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movq 0x8(%rax), %rsi
callq 0x5350
cmpl $0x0, %eax
je 0x12e4d
movl $0x0, -0x4(%rbp)
jmp 0x12ec7
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x12e98
movq -0x30(%rbp), %rax
movq 0xa166(%rip), %rcx      # 0x1cfe0
movq (%rcx), %rdi
movq 0x8(%rax), %rdx
leaq 0x299f(%rip), %rsi      # 0x15827
movb $0x0, %al
callq 0x5370
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ec7
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq -0x23(%rbp), %rdi
callq 0x12a30
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movw -0x23(%rbp), %cx
movw %cx, (%rax)
movb -0x21(%rbp), %cl
movb %cl, 0x2(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x1302e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rax), %rsi
callq 0x5160
cmpl $0x0, %eax
je 0x12ffd
leaq 0x29c5(%rip), %rdi      # 0x159bd
callq 0xfee0
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edi
callq 0x5480
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq $0x0, 0x10(%rax)
jmp 0x13067
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13065
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13059
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x52c0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x13067
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
jne 0x130e4
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, (%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
imulq $0x3, %rax, %rdi
callq 0x5030
movq -0x30(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq 0x10(%rcx), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rcx), %rax
imulq 0x8(%rcx), %rax
imulq $0x3, %rax, %rdx
callq 0x5230
jmp 0x131ad
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x31(%rbp)
jge 0x13111
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setl %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1311d
jmp 0x131ab
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x32(%rbp)
jge 0x13148
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setl %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x13151
jmp 0x13198
leaq -0x23(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x74b0
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x23(%rbp), %rcx
callq 0x14290
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x23(%rbp), %rcx
callq 0x142d0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13125
jmp 0x1319a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x130ec
jmp 0x131ad
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x13507
leaq 0x260e(%rip), %rdi      # 0x15b10
callq 0xfea0
jmp 0x13509
movq -0x8(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x22(%rbp)
jae 0x1352c
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x13535
jmp 0x13573
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jne 0x1355a
jmp 0x13573
movb -0x21(%rbp), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13509
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x23, %ecx
movb %al, -0x23(%rbp)
je 0x135a0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x23(%rbp)
movb -0x23(%rbp), %al
testb $0x1, %al
jne 0x134e7
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdq 0x8(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x215f(%rip), %xmm1     # 0x15948
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
cvtsi2sdq (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x2138(%rip), %xmm1     # 0x15940
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x68(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq 0x8(%rcx), %rax
jge 0x13898
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x13930
movq -0x68(%rbp), %rax
movaps %xmm0, %xmm1
cvtsi2sdq (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x13888
movsd -0x40(%rbp), %xmm0
callq 0x13930
movq -0x68(%rbp), %rdi
cvttsd2si %xmm0, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rsi
imulq (%rdi), %rsi
addq -0x48(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7590
movsd -0x30(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x1382f
jmp 0x1388a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x13819
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
callq 0x13930
movq -0x68(%rbp), %rax
movaps %xmm0, %xmm1
cvtsi2sdq 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1391f
movsd -0x50(%rbp), %xmm0
callq 0x13930
cvttsd2si %xmm0, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %rax
cmpq (%rcx), %rax
jge 0x1390c
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rsi
imulq (%rdi), %rsi
addq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7590
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x138d8
jmp 0x1390e
movsd -0x28(%rbp), %xmm0
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
jmp 0x138a0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x8(%rax), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x68(%rbp), %rax
cvtsi2sd %rcx, %xmm0
movsd %xmm0, -0x28(%rbp)
movq (%rax), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq -0x68(%rbp), %rax
cvtsi2sd %rcx, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x68(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
jge 0x13ad5
movsd -0x28(%rbp), %xmm0
cvtsi2sdq -0x40(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x48(%rbp), %xmm0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x50(%rbp)
movq -0x68(%rbp), %rcx
movq -0x50(%rbp), %rax
cmpq (%rcx), %rax
jge 0x13ac2
movq -0x68(%rbp), %rcx
cvtsi2sdq -0x50(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq (%rcx), %rcx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x58(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movw %ax, %cx
movw %cx, -0x5b(%rbp)
shrl $0x10, %eax
movb %al, -0x59(%rbp)
leaq -0x5b(%rbp), %rdx
callq 0x7590
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x13a2b
jmp 0x13ac4
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x139dc
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x13e42
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jg 0x13e35
movsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x30(%rbp), %xmm1
addsd %xmm1, %xmm0
callq 0x13930
cvttsd2si %xmm0, %rax
movq %rax, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
addsd %xmm1, %xmm0
callq 0x13930
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
cvttsd2si %xmm0, %rdx
movq -0x28(%rbp), %rcx
callq 0x14330
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x13ddd
jmp 0x13e37
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13dcd
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x13ef4
movq -0x48(%rbp), %rdi
movsd -0x10(%rbp), %xmm1
cvtsi2sdl -0x3c(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd -0x10(%rbp), %xmm2
movl -0x3c(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd -0x38(%rbp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0xa, %ecx
callq 0x13f00
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x13e98
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ashlall[P]StreamStats/Test/QDigest_test_Double.cpp
// Function: test_reverse()
void test_reverse()
{
	QDigestDouble larry(3000);
	int stream_size =88888;
	double item;
	
	default_random_engine generator;
    normal_distribution<double> distribution(3000,50);
    
    for (int i=0; i<stream_size; i++) 
    {
    	item = distribution(generator);
    	//item = i;
  	    larry.insert(item);
  	}
  	
  	double median;
  	median = larry.getQuantile(0.5);
  	cout << median << endl;
  	
  	double median_index;
  	median_index = larry.reverseQuantile(3000, stream_size);
  	cout << median_index << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
leaq -0x80(%rbp), %rdi
movsd 0x87f9(%rip), %xmm0     # 0xd050
callq 0x55d0
movl $0x15b38, -0x84(%rbp)   # imm = 0x15B38
leaq -0x98(%rbp), %rdi
callq 0x5740
jmp 0x4874
leaq -0xc8(%rbp), %rdi
movsd 0x87cd(%rip), %xmm0     # 0xd050
movsd 0x87cd(%rip), %xmm1     # 0xd058
callq 0x5760
jmp 0x4892
movl $0x0, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
cmpl -0x84(%rbp), %eax
jge 0x491d
leaq -0xc8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x57b0
movsd %xmm0, -0xe8(%rbp)
jmp 0x48c7
movsd -0xe8(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
movsd -0x90(%rbp), %xmm0
leaq -0x80(%rbp), %rdi
callq 0x5630
jmp 0x48ea
jmp 0x48ec
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x489c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5720
jmp 0x49ef
leaq -0x80(%rbp), %rdi
movsd 0x870f(%rip), %xmm0     # 0xd038
callq 0x56e0
movsd %xmm0, -0xf0(%rbp)
jmp 0x4938
movsd -0xf0(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movsd -0xd8(%rbp), %xmm0
movq 0xf679(%rip), %rdi      # 0x13fd0
callq 0x2230
movq %rax, -0xf8(%rbp)
jmp 0x4965
movq -0xf8(%rbp), %rdi
movq 0xf64d(%rip), %rsi      # 0x13fc0
callq 0x2170
jmp 0x497a
movl -0x84(%rbp), %esi
leaq -0x80(%rbp), %rdi
movsd 0x86c4(%rip), %xmm0     # 0xd050
callq 0x2380
movsd %xmm0, -0x100(%rbp)
jmp 0x499b
movsd -0x100(%rbp), %xmm0
movsd %xmm0, -0xe0(%rbp)
movsd -0xe0(%rbp), %xmm0
movq 0xf616(%rip), %rdi      # 0x13fd0
callq 0x2230
movq %rax, -0x108(%rbp)
jmp 0x49c8
movq -0x108(%rbp), %rdi
movq 0xf5ea(%rip), %rsi      # 0x13fc0
callq 0x2170
jmp 0x49dd
leaq -0x80(%rbp), %rdi
callq 0x5720
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x2220
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
cmpb $0x0, 0x11549(%rip)     # 0x154f8
jne 0x3ff6
leaq 0x11540(%rip), %rdi     # 0x154f8
callq 0x2280
cmpl $0x0, %eax
je 0x3ff6
leaq 0x101a7(%rip), %rdi     # 0x14170
callq 0x51b0
jmp 0x3fd0
leaq 0x1279(%rip), %rdi      # 0x5250
leaq 0x10192(%rip), %rsi     # 0x14170
leaq 0x10173(%rip), %rdx     # 0x14158
callq 0x2140
leaq 0x11507(%rip), %rdi     # 0x154f8
callq 0x2110
cmpb $0x0, 0x1288b(%rip)     # 0x16888
jne 0x4042
leaq 0x12882(%rip), %rdi     # 0x16888
callq 0x2280
cmpl $0x0, %eax
je 0x4042
leaq 0x10159(%rip), %rdi     # 0x14170
callq 0x5280
movl %eax, -0x20(%rbp)
jmp 0x4021
movl -0x20(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x114d1(%rip), %rdi     # 0x15500
callq 0x52a0
jmp 0x4036
leaq 0x1284b(%rip), %rdi     # 0x16888
callq 0x2110
cmpb $0x0, 0x1284f(%rip)     # 0x16898
jne 0x407d
leaq 0x12846(%rip), %rdi     # 0x16898
callq 0x2280
cmpl $0x0, %eax
je 0x407d
leaq 0x1282d(%rip), %rdi     # 0x16890
xorl %esi, %esi
movl $0x1, %edx
callq 0x52d0
jmp 0x4071
leaq 0x12820(%rip), %rdi     # 0x16898
callq 0x2110
leaq 0x1280c(%rip), %rdi     # 0x16890
leaq 0x11475(%rip), %rsi     # 0x15500
callq 0x53b0
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x53e0
leaq -0x18(%rbp), %rdi
callq 0x5300
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x11436(%rip), %rdi     # 0x154f8
callq 0x2100
jmp 0x40fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x127ac(%rip), %rdi     # 0x16888
callq 0x2100
jmp 0x40fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x127a2(%rip), %rdi     # 0x16898
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
cmpb $0x0, 0x13b09(%rip)     # 0x17c28
jne 0x4166
leaq 0x13b00(%rip), %rdi     # 0x17c28
callq 0x2280
cmpl $0x0, %eax
je 0x4166
leaq 0x12767(%rip), %rdi     # 0x168a0
callq 0x51b0
jmp 0x4140
leaq 0x1109(%rip), %rdi      # 0x5250
leaq 0x12752(%rip), %rsi     # 0x168a0
leaq 0x10003(%rip), %rdx     # 0x14158
callq 0x2140
leaq 0x13ac7(%rip), %rdi     # 0x17c28
callq 0x2110
cmpb $0x0, 0x14e4b(%rip)     # 0x18fb8
jne 0x41b2
leaq 0x14e42(%rip), %rdi     # 0x18fb8
callq 0x2280
cmpl $0x0, %eax
je 0x41b2
leaq 0x12719(%rip), %rdi     # 0x168a0
callq 0x5280
movl %eax, -0x10(%rbp)
jmp 0x4191
movl -0x10(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
leaq 0x13a91(%rip), %rdi     # 0x17c30
callq 0x52a0
jmp 0x41a6
leaq 0x14e0b(%rip), %rdi     # 0x18fb8
callq 0x2110
cmpb $0x0, 0x14e0f(%rip)     # 0x18fc8
jne 0x41f0
leaq 0x14e06(%rip), %rdi     # 0x18fc8
callq 0x2280
cmpl $0x0, %eax
je 0x41f0
leaq 0x14ded(%rip), %rdi     # 0x18fc0
movl $0x1, %esi
movl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
callq 0x52d0
jmp 0x41e4
leaq 0x14ddd(%rip), %rdi     # 0x18fc8
callq 0x2110
leaq 0x14dc9(%rip), %rdi     # 0x18fc0
leaq 0x13a32(%rip), %rsi     # 0x17c30
callq 0x53b0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x13a0c(%rip), %rdi     # 0x17c28
callq 0x2100
jmp 0x4255
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x14d82(%rip), %rdi     # 0x18fb8
callq 0x2100
jmp 0x4255
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq 0x14d78(%rip), %rdi     # 0x18fc8
callq 0x2100
movq -0x8(%rbp), %rdi
callq 0x2260
nop
// File: shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shareable_lock_template<gx::shared_lock_t>::~shareable_lock_template()
~shareable_lock_template()
		{
			if (m_mutex && is_locked)
			{
				if (m_mode == lock_mode::shared)
					m_mutex->unlock_shared();
				else
					m_mutex->unlock();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x4300
movq -0x10(%rbp), %rax
testb $0x1, 0xc(%rax)
je 0x4300
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x42ee
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6000
jmp 0x42ec
jmp 0x42fe
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x60d0
jmp 0x42fc
jmp 0x42fe
jmp 0x4300
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3d00
nop
// File: shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::lock_shared()
void lock_shared()
		{
			while (true)
			{
				m_counter.fetch_add(1, std::memory_order_acq_rel);
				if (m_exclusive.load(std::memory_order_acquire))
					m_counter.fetch_sub(1, std::memory_order_acq_rel);
				else
					break;
				while (m_exclusive.load(std::memory_order_acquire)) delay();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x38(%rbp)
movl $0x4, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
movq %rcx, -0x48(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x68(%rbp)
subl $0x4, %eax
ja 0x4376
movq -0x68(%rbp), %rax
leaq 0x7c97(%rip), %rcx      # 0xc004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x43d3
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x43d3
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x43d3
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x50(%rbp)
jmp 0x43d3
movq -0x70(%rbp), %rcx
movq -0x48(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x50(%rbp)
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movl $0x2, %esi
callq 0x44e0
testb $0x1, %al
jne 0x43ee
jmp 0x44ab
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x78(%rbp)
subl $0x4, %eax
ja 0x443d
movq -0x78(%rbp), %rax
leaq 0x7be4(%rip), %rcx      # 0xc018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x44a9
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x44a9
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x44a9
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x44a9
movq -0x80(%rbp), %rcx
movq -0x20(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x44ad
jmp 0x44d7
jmp 0x44af
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movl $0x2, %esi
callq 0x44e0
testb $0x1, %al
jne 0x44c7
jmp 0x44d2
movq -0x60(%rbp), %rdi
callq 0x4570
jmp 0x44af
jmp 0x4327
addq $0x80, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
jne 0x4590
callq 0x45e0
jmp 0x45b5
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x45b3
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x10(%rbp), %rdi
callq 0x46b0
leaq -0x10(%rbp), %rdi
callq 0x4600
jmp 0x45b5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::unlock_and_lock_shared()
void unlock_and_lock_shared()
		{
			if (m_priority_exclusive.load(std::memory_order_acquire) > 0)
			{
				m_priority_exclusive.fetch_sub(1, std::memory_order_acq_rel);
			}
			else
			{
				m_counter.fetch_add(1, std::memory_order_acq_rel);
				m_exclusive.store(false, std::memory_order_release);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x45c0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
decl %eax
subl $0x2, %eax
jb 0x5d87
jmp 0x5d70
movl -0x74(%rbp), %eax
subl $0x5, %eax
je 0x5d94
jmp 0x5d7a
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5d9f
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5d9f
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x5e85
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movl $0x4, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq %rcx, -0x38(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x90(%rbp)
subl $0x4, %eax
ja 0x5e05
movq -0x90(%rbp), %rax
leaq 0x6280(%rip), %rcx      # 0xc07c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x5e80
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x5e80
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x5e80
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x5e80
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x5f63
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq $0x1, -0x50(%rbp)
movl $0x4, -0x54(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x54(%rbp), %eax
movq -0x50(%rbp), %rcx
movq %rcx, -0x60(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0xa0(%rbp)
subl $0x4, %eax
ja 0x5ee0
movq -0xa0(%rbp), %rax
leaq 0x6191(%rip), %rcx      # 0xc068
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x5f4c
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x5f4c
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x5f4c
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x5f4c
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x5f70
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shared_mutex::unlock()
void unlock()
		{
			if (m_priority_exclusive.load(std::memory_order_acquire) > 0)
			{
				m_priority_exclusive.fetch_sub(1, std::memory_order_acq_rel);
				m_counter.fetch_sub(1, std::memory_order_acq_rel);
			}
			else
				m_exclusive.store(false, std::memory_order_release);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x45c0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
decl %eax
subl $0x2, %eax
jb 0x6137
jmp 0x6120
movl -0x74(%rbp), %eax
subl $0x5, %eax
je 0x6144
jmp 0x612a
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x614f
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x614f
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x6308
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movl $0x4, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq %rcx, -0x38(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0x90(%rbp)
subl $0x4, %eax
ja 0x61b5
movq -0x90(%rbp), %rax
leaq 0x5ef8(%rip), %rcx      # 0xc0a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x6230
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x6230
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x6230
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x6230
movq -0x98(%rbp), %rcx
movq -0x38(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x40(%rbp)
movq -0x88(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq $0x1, -0x50(%rbp)
movl $0x4, -0x54(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x54(%rbp), %eax
movq -0x50(%rbp), %rcx
movq %rcx, -0x60(%rbp)
decl %eax
movl %eax, %ecx
movq %rcx, -0xa0(%rbp)
subl $0x4, %eax
ja 0x628b
movq -0xa0(%rbp), %rax
leaq 0x5e36(%rip), %rcx      # 0xc0b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x6306
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x6306
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x6306
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x6306
movq -0xa8(%rbp), %rcx
movq -0x60(%rbp), %rax
negq %rax
lock
xaddq %rax, (%rcx)
movq %rax, -0x68(%rbp)
jmp 0x631f
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x5f70
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
leaq -0x21(%rbp), %rsi
movl $0x1, %edx
movl $0x4, %ecx
movl $0x2, %r8d
callq 0x4d50
xorb $-0x1, %al
testb $0x1, %al
jne 0x6aa1
jmp 0x6ab0
movq -0x30(%rbp), %rdi
callq 0x4570
movb $0x0, -0x21(%rbp)
jmp 0x6a78
jmp 0x6ab2
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movl $0x2, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x45c0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
decl %eax
subl $0x2, %eax
jb 0x6b03
jmp 0x6aec
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x6b10
jmp 0x6af6
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6b1b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6b1b
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x6b2d
movq -0x30(%rbp), %rdi
callq 0x4570
jmp 0x6ab2
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: shutow[P]shared_mutex/./shared_mutex.h
// Function: gx::shareable_lock_template<gx::shared_lock_t>::shareable_lock_template(gx::shared_mutex&, gx::lock_mode)
shareable_lock_template(shared_mutex& mutex, lock_mode mode)
			: m_mutex(&mutex), m_mode(mode), is_locked(false)
		{
			if (m_mode == lock_mode::shared)
				m_mutex->lock_shared();
			else
				m_mutex->lock();
			is_locked = true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movb $0x0, 0xc(%rax)
cmpl $0x0, 0x8(%rax)
jne 0x6b80
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x4310
jmp 0x6b8c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x6a60
movq -0x20(%rbp), %rax
movb $0x1, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x378, %rsp            # imm = 0x378
movl %edi, 0x374(%rsp)
leaq 0x1e8(%rsp), %rdi
callq 0x3180
leaq 0x1f8(%rsp), %rdi
leaq 0xf9c6(%rip), %rsi      # 0x13050
callq 0x3280
jmp 0x3691
leaq 0x1b8(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x3270
jmp 0x36a8
leaq 0x1b8(%rsp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x3220
jmp 0x36bf
leaq 0x1b8(%rsp), %rdi
callq 0x3160
movq 0x14905(%rip), %rdi     # 0x17fd8
leaq 0xf989(%rip), %rsi      # 0x13063
callq 0x3280
movq %rax, 0x8(%rsp)
jmp 0x36e6
movq 0x8(%rsp), %rdi
movq 0x148d6(%rip), %rsi     # 0x17fc8
callq 0x32c0
jmp 0x36f9
leaq 0x30(%rsp), %rdi
callq 0x3180
jmp 0x3705
leaq 0x40(%rsp), %rdi
leaq 0xf967(%rip), %rsi      # 0x13078
callq 0x3280
jmp 0x3718
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3270
jmp 0x3729
leaq 0x10(%rsp), %rdi
callq 0x30e0
movq %rax, %rdi
callq 0x3220
jmp 0x373d
leaq 0x10(%rsp), %rdi
callq 0x3160
movq 0x1488a(%rip), %rdi     # 0x17fd8
leaq 0xf935(%rip), %rsi      # 0x1308a
callq 0x3280
jmp 0x375c
xorl %edi, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
jmp 0x37da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
leaq 0x1b8(%rsp), %rdi
callq 0x3160
jmp 0x37da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
jmp 0x37d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x3160
leaq 0x30(%rsp), %rdi
callq 0x31b0
leaq 0x1e8(%rsp), %rdi
callq 0x31b0
movq 0x1e0(%rsp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x278d
movq 0x20(%rsp), %rdi
callq 0x2c60
movl %eax, 0x14(%rsp)
leaq 0x8a20(%rip), %rdi      # 0xb138
leaq 0x14(%rsp), %rsi
callq 0x2d40
movq %rax, 0x8(%rsp)
leaq 0x8a0a(%rip), %rdi      # 0xb138
callq 0x2a90
movq %rax, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x2d20
testb $0x1, %al
jne 0x274a
jmp 0x2763
leaq 0x89e7(%rip), %rdi      # 0xb138
leaq 0x14(%rsp), %rsi
callq 0x2d70
movl $0x1, (%rax)
jmp 0x277b
leaq 0x89ce(%rip), %rdi      # 0xb138
leaq 0x14(%rsp), %rsi
callq 0x2d70
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x277d
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x26f5
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x50, %rsi
leaq 0x30(%rsp), %rdi
callq 0x5490
movq 0x18(%rsp), %rdi
callq 0x5e50
movb %al, 0x17(%rsp)
jmp 0x2c91
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x2c9b
jmp 0x2cca
movq 0x18(%rsp), %rdi
addq $0x78, %rdi
leaq 0x30(%rsp), %rsi
callq 0x2050
jmp 0x2c81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5500
jmp 0x2d0d
movq 0x18(%rsp), %rdi
callq 0x5e70
movq %rax, 0x8(%rsp)
jmp 0x2cdb
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x20(%rsp)
callq 0x5e80
jmp 0x2cf2
movl 0x20(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5500
movl 0x4(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x2200
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10020, %rsp          # imm = 0x10020
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x11(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1040
leaq -0x10018(%rbp), %rdi
callq 0x1230
leaq -0x10018(%rbp), %rdi
callq 0x1270
movq 0x6db8(%rip), %rdi      # 0x7fd0
movq 0x6da1(%rip), %rsi      # 0x7fc0
callq 0x1060
xorl %eax, %eax
addq $0x10020, %rsp          # imm = 0x10020
popq %rbp
retq
nop
// File: kmichel[P]bf0x/./bf0x.hpp
// Function: bf0x::interpreter<bf0x::bstack<bf0x::interpreter>, (char)91, (char)60, (char)45, (char)45, (char)45, (char)45, (char)45, (char)45, (char)60, (char)45, (char)45, (char)45, (char)45, (char)45, (char)45, (char)62, (char)62, (char)45, (char)93, (char)60, (char)60, (char)91, (char)62, (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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x10000(%rcx), %ecx
cmpb $0x0, (%rax,%rcx)
je 0x1595
movl $0x0, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x158a
jmp 0x157f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1577
movq -0x8(%rbp), %rdi
callq 0x15c0
jmp 0x155c
movl $0x0, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0x15af
jmp 0x15a4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x159c
movq -0x8(%rbp), %rdi
callq 0x15e0
addq $0x10, %rsp
popq %rbp
retq
nop