LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/optionParser.c
// Function: parseConfigFileOption
int parseConfigFileOption(char* configFile, int *argc, char*** argv, struct SOption *option, struct SOptionOut **cmdOptionLine)
{
	FILE *f=fopen(configFile,"r");
	char arg[256];
	int i;

	if (f == NULL)
		RET_ERROR(ERROR_UNKNOWN, "Unable to open file");

	while(!feof(f))
	{
		char c;
		c=fgetc(f);
		while ((c==' ' || c=='\t' || c=='\n') && !feof(f))
			c=fgetc(f);
		if (feof(f))
			continue;
		i=0;
		if (c == ';')
		{
			char comment[256];
			fgets(comment,256,f);
		}
		else
		{
			while ((!(c==' ' || c=='\t' || c=='\n')) && !feof(f))
			{
				arg[i++] = c;
				c=fgetc(f);
			}
			arg[i]=0;
			addArgv(argc,argv,arg);
		}
	}
	fclose(f);

	return parseCommandLineOption(argc,argv,option,cmdOptionLine);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x72f9(%rip), %rsi      # 0x10a69
callq 0x3340
testq %rax, %rax
je 0x9881
movq %rax, %r13
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %rax, %rdi
callq 0x3490
testl %eax, %eax
jne 0x9863
movabsq $0x100000600, %rbx      # imm = 0x100000600
movq %r13, %rdi
callq 0x34a0
movl %eax, %ebp
movl %eax, %r14d
shll $0x18, %r14d
cmpl $0x9000000, %r14d       # imm = 0x9000000
je 0x97d0
cmpl $0x20000000, %r14d      # imm = 0x20000000
je 0x97d0
cmpl $0xa000000, %r14d       # imm = 0xA000000
jne 0x97dc
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
je 0x97a4
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
jne 0x9853
cmpl $0x3b000000, %r14d      # imm = 0x3B000000
jne 0x9808
leaq 0x110(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movq %r13, %rdx
callq 0x34b0
jmp 0x9853
xorl %r14d, %r14d
cmpb $0x20, %bpl
ja 0x981b
movzbl %bpl, %eax
btq %rax, %rbx
jb 0x983b
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
jne 0x983b
movb %bpl, 0x10(%rsp,%r14)
incq %r14
movq %r13, %rdi
callq 0x34a0
movl %eax, %ebp
jmp 0x980b
movl %r14d, %eax
movb $0x0, 0x10(%rsp,%rax)
movq %r12, %rdi
movq %r15, %rsi
leaq 0x10(%rsp), %rdx
callq 0x8d97
movq %r13, %rdi
callq 0x3490
testl %eax, %eax
je 0x97a4
movq %r13, %rdi
callq 0x32b0
movq %r12, %rdi
movq %r15, %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x9456
jmp 0x98a8
movl $0xffffffff, 0xcd15(%rip) # imm = 0xFFFFFFFF
movups 0x725b(%rip), %xmm0     # 0x10aed
movaps %xmm0, 0xcd17(%rip)     # 0x165b0
movl $0x656c69, 0xcd1d(%rip) # imm = 0x656C69
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/optionParser.c
// Function: parseCommandLine
int parseCommandLine(int *argc, char*** argv,
					 struct SOption *option, struct SOptionOut **commandLine,
					 int nbMinArg, int noConfig)
{
	if (parseCommandLineOption(argc,argv,option,commandLine) != OPT_NO_ERROR)
	{
		return getError();
	}

	if (!noConfig)
	{
		int o;
		if ((o=optionIndex(*commandLine,'c')) != ERROR_UNKNOWN)
		{
			if (parseConfigFileOption((*commandLine)[o].argv[0],argc,argv,option,commandLine) != OPT_NO_ERROR)
			{
				return getError();
			}
		}
	}

	if ((*argc) <= nbMinArg && nbMinArg >= 0)
	{
		char errorStr[1024];
		sprintf(errorStr, "Wrong number of arg, %d expected\n\n", nbMinArg);
		RET_ERROR(ERROR_NBARG, errorStr);
	}
	return OPT_NO_ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %r9d, %ebp
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x9456
testl %eax, %eax
je 0x9acc
movl 0xcae6(%rip), %eax      # 0x165a0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x9b11
xorl %eax, %eax
testl %ebx, %ebx
js 0x9aba
cmpl %ebx, (%r14)
jg 0x9aba
leaq 0x7058(%rip), %rsi      # 0x10b3a
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3090
movl $0xfffffffb, 0xcaa5(%rip) # imm = 0xFFFFFFFB
leaq 0xcaae(%rip), %rdi      # 0x165b0
movq %r14, %rsi
callq 0x3270
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
jmp 0x9aba
movq (%r15), %rdi
movl $0x63, %esi
callq 0x924a
cmpl $-0x1, %eax
je 0x9ad0
movq (%r15), %rcx
cltq
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
movq (%rax), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x974c
testl %eax, %eax
jne 0x9ab4
jmp 0x9ad0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/rs232.c
// Function: RS232_CloseComport
void RS232_CloseComport(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_DTR;    /* turn off DTR */
  status &= ~TIOCM_RTS;    /* turn off RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }

  close(handle);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa0b5
leaq 0xc(%rsp), %rdx
andb $-0x7, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa0c3
movl %ebx, %edi
callq 0x3570
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6b61(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa08d
leaq 0x6b6c(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa0a8
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/rs232.c
// Function: RS232_enableDTR
void RS232_enableDTR(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status |= TIOCM_DTR;    /* turn on DTR */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa17d
leaq 0xc(%rsp), %rdx
orb $0x2, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa18b
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6a99(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa15c
leaq 0x6aa4(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa177
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/rs232.c
// Function: RS232_disableDTR
void RS232_disableDTR(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_DTR;    /* turn off DTR */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa1d7
leaq 0xc(%rsp), %rdx
andb $-0x3, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa1e5
addq $0x10, %rsp
popq %rbx
retq
leaq 0x6a3f(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa1b6
leaq 0x6a4a(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa1d1
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/rs232.c
// Function: RS232_enableRTS
void RS232_enableRTS(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status |= TIOCM_RTS;    /* turn on RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa231
leaq 0xc(%rsp), %rdx
orb $0x4, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa23f
addq $0x10, %rsp
popq %rbx
retq
leaq 0x69e5(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa210
leaq 0x69f0(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa22b
// File: /workspace/github_cpp_makefile_star2_O3/pelrun[P]aft/rs232.c
// Function: RS232_disableRTS
void RS232_disableRTS(HANDLE handle)
{
  int status;

  if(ioctl(handle, TIOCMGET, &status) == -1)
  {
    perror("unable to get portstatus");
  }

  status &= ~TIOCM_RTS;    /* turn off RTS */

  if(ioctl(handle, TIOCMSET, &status) == -1)
  {
    perror("unable to set portstatus");
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leaq 0xc(%rsp), %rdx
movl $0x5415, %esi           # imm = 0x5415
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa28b
leaq 0xc(%rsp), %rdx
andb $-0x5, (%rdx)
movl $0x5418, %esi           # imm = 0x5418
movl %ebx, %edi
xorl %eax, %eax
callq 0x3420
cmpl $-0x1, %eax
je 0xa299
addq $0x10, %rsp
popq %rbx
retq
leaq 0x698b(%rip), %rdi      # 0x10c1d
callq 0x3230
jmp 0xa26a
leaq 0x6996(%rip), %rdi      # 0x10c36
callq 0x3230
jmp 0xa285
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::reader_lock()
void RWLock::reader_lock()
{
  unique_lock<std::mutex> l(lock);
  if(writers.load() || write_waiters.load())
  {
    read_waiters.fetch_add(1);
    do { read.wait(l); }
    while(writers.load() || write_waiters.load());
    read_waiters.fetch_sub(1);
  }
  readers.fetch_add(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4a56
movb $0x1, 0x8(%r14)
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x48c3
movl 0xc(%rbx), %eax
testl %eax, %eax
je 0x48ec
lock
incl 0x8(%rbx)
leaq 0x38(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x48cf
movl 0xc(%rbx), %eax
testl %eax, %eax
jne 0x48cf
lock
decl 0x8(%rbx)
lock
incl (%rbx)
leaq -0x28(%rbp), %rdi
callq 0x4a3c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::reader_release()
void RWLock::reader_release()
{
  unique_lock<std::mutex> l(lock);
  readers.fetch_sub(1);
  if(writers.load() > 0){
    write.notify_all();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4a56
movb $0x1, 0x8(%r14)
lock
decl (%rbx)
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x4945
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x43d0
leaq -0x20(%rbp), %rdi
callq 0x4a3c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::writer_lock()
void RWLock::writer_lock()
{
  unique_lock<std::mutex> l(lock);
  if(readers.load() || writers.load()){
    write_waiters.fetch_add(1);
    do { write.wait(l); }
    while(readers.load() || writers.load());
    write_waiters.fetch_sub(1);
  }
  writers.store(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x28(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4a56
movb $0x1, 0x8(%r14)
movl (%rbx), %eax
testl %eax, %eax
jne 0x4992
movl 0x4(%rbx), %eax
testl %eax, %eax
je 0x49ba
lock
incl 0xc(%rbx)
leaq 0x68(%rbx), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4090
movl (%rbx), %eax
testl %eax, %eax
jne 0x499e
movl 0x4(%rbx), %eax
testl %eax, %eax
jne 0x499e
lock
decl 0xc(%rbx)
movl $0x1, %eax
xchgl %eax, 0x4(%rbx)
leaq -0x28(%rbp), %rdi
callq 0x4a3c
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/rwlock.cpp
// Function: RWLock::writer_release()
void RWLock::writer_release()
{
  unique_lock<std::mutex> l(lock);
  writers.store(0);
  if(write_waiters.load()){
    write.notify_all();
  } else if(read_waiters.load()){
    read.notify_all();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4a56
movb $0x1, 0x8(%r14)
xorl %eax, %eax
xchgl %eax, 0x4(%rbx)
movl 0xc(%rbx), %ecx
movl $0x68, %eax
testl %ecx, %ecx
jne 0x4a1e
movl 0x8(%rbx), %ecx
movl $0x38, %eax
testl %ecx, %ecx
je 0x4a29
addq %rax, %rbx
movq %rbx, %rdi
callq 0x43d0
leaq -0x20(%rbp), %rdi
callq 0x4a3c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: build_buffer(int, int)
RecordBuffer build_buffer(int len, int max)
{
  int i;
  RecordBuffer buff(new std::vector<Record>(len));
  for(i = 0; i < len; i++){
    (*buff)[i].key = rand() % max;
    (*buff)[i].value = (Value)0xDEADBEEF;
  }
  return buff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl $0x18, %edi
callq 0x4270
movq %rax, %r12
movslq %r15d, %rsi
leaq -0x29(%rbp), %rdx
movq %rax, %rdi
callq 0x6466
movq %r12, (%r14)
leaq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x67c8
testl %r15d, %r15d
jle 0x4b55
movl %r15d, %r15d
shlq $0x4, %r15
xorl %r12d, %r12d
movl $0xdeadbeef, %r13d      # imm = 0xDEADBEEF
callq 0x4070
cltd
idivl %ebx
movslq %edx, %rax
movq (%r14), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx,%r12)
movq %r13, 0x8(%rcx,%r12)
addq $0x10, %r12
cmpq %r12, %r15
jne 0x4b32
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x18, %esi
movq %r12, %rdi
callq 0x4280
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: load_buffer(std::istream&)
RecordBuffer load_buffer(istream &input)
{
  RecordBuffer ret(new vector<Record>());
  Record r;
  r.value = (Value)0xDEADBEEF;
  while(!input.eof()){
    input >> r.key;
    ret->push_back(r);
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r12d, %r12d
movq %r12, 0x10(%rax)
movq %rax, (%rbx)
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x67c8
movq %r12, -0x30(%rbp)
movl $0xdeadbeef, %eax       # imm = 0xDEADBEEF
movq %rax, -0x28(%rbp)
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
jne 0x4c1a
leaq -0x30(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x4290
movq (%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x4c03
movups -0x30(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rdi)
jmp 0x4c0b
movq %r12, %rdx
callq 0x68a8
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x20(%r14,%rax)
je 0x4bdd
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4c3a
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/cog_tester.cpp
// Function: build_random_sorted_array(int, int)
RecordCogHandle build_random_sorted_array(int len, int max)
{
  RecordBuffer buff = build_buffer(len, max);
  sort(buff->begin(), buff->end());
  return CogHandle<Record>(new CogHandleBase<Record>(CogPtr<Record>(
          new SortedArrayCog<Record>(buff, buff->begin(), buff->end()))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %r14
movq %r14, %rdi
callq 0x4adc
movq (%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x4e5d
movq %r15, %rax
subq %r14, %rax
sarq $0x4, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7074
movq %r14, %rdi
movq %r15, %rsi
callq 0x7179
movl $0x10, %edi
callq 0x4270
movq %rax, %r15
movl $0x30, %edi
callq 0x4270
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r14
testq %r14, %r14
je 0x4e96
movq 0x13138(%rip), %rdi     # 0x17fc0
cmpb $0x0, (%rdi)
je 0x4eb8
incl 0x8(%r14)
movq %rcx, %rsi
jmp 0x4ec1
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movl $0x4, 0x8(%rax)
leaq 0x129a5(%rip), %rdi     # 0x17850
movq %rdi, (%rax)
movq %rcx, 0x10(%rax)
movq %r14, 0x18(%rax)
jmp 0x4ef1
lock
incl 0x8(%r14)
movq -0x28(%rbp), %rsi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movl $0x4, 0x8(%rax)
leaq 0x1297a(%rip), %r8      # 0x17850
movq %r8, (%rax)
movq %rcx, 0x10(%rax)
movq %r14, 0x18(%rax)
cmpb $0x0, (%rdi)
je 0x4eec
incl 0x8(%r14)
jmp 0x4ef1
lock
incl 0x8(%r14)
movq %rdx, 0x20(%rax)
movq %rsi, 0x28(%rax)
leaq -0x30(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x7650
movq -0x38(%rbp), %rax
movq %rax, (%r15)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x4f32
movq 0x1309c(%rip), %rcx     # 0x17fc0
cmpb $0x0, (%rcx)
je 0x4f2e
incl 0x8(%rax)
jmp 0x4f32
lock
incl 0x8(%rax)
movq %r15, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r15, %rsi
callq 0x6f94
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4f4f
callq 0x65c2
testq %r14, %r14
je 0x4f5c
movq %r14, %rdi
callq 0x65c2
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x4f6a
callq 0x65c2
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x4f89
callq 0x65c2
testq %r14, %r14
je 0x4fbf
movq %r14, %rdi
callq 0x65c2
jmp 0x4fbf
movq %rax, %rbx
testq %r14, %r14
je 0x4fad
movq %r14, %rdi
callq 0x65c2
jmp 0x4fad
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x4280
jmp 0x4fbf
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x4fcd
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/cog/ArrayCog.hpp
// Function: ArrayCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "Array[" << (end-start) << " elements] : { ";
      BufferElement<Tuple> curr = start;
      int i = 0;
      for(; (i < 6) && (curr != end); ++curr, ++i){
        std::cout << (i != 0 ? ", " : "") << curr->key;
      }
      if(curr != end) { std::cout << " ... "; }
      std::cout << " }\n";
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x6b00
movl %esi, %r14d
incl %r14d
movq 0x114e8(%rip), %r15     # 0x17fc8
leaq 0xa648(%rip), %r12      # 0x1112f
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r14d
cmpl $0x1, %r14d
ja 0x6ae7
movq 0x114c1(%rip), %r14     # 0x17fc8
leaq 0xa647(%rip), %rsi      # 0x11155
movl $0x6, %edx
movq %r14, %rdi
callq 0x42d0
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x4, %rsi
movq %r14, %rdi
callq 0x4230
leaq 0xa5fc(%rip), %rsi      # 0x11132
movl $0xf, %edx
movq %rax, %rdi
callq 0x42d0
movq 0x20(%rbx), %r15
cmpq %r15, 0x28(%rbx)
je 0x6bbc
xorl %r12d, %r12d
leaq 0xa5eb(%rip), %r13      # 0x11142
movq 0x1146a(%rip), %r14     # 0x17fc8
xorl %edx, %edx
testl %r12d, %r12d
setne %dl
movq %r13, %rsi
leaq 0xad51(%rip), %rax      # 0x118c1
cmoveq %rax, %rsi
addl %edx, %edx
movq %r14, %rdi
callq 0x42d0
movq (%r15), %rsi
movq %r14, %rdi
callq 0x4230
addq $0x10, %r15
movq 0x28(%rbx), %rax
cmpl $0x4, %r12d
ja 0x6b9f
incl %r12d
cmpq %rax, %r15
jne 0x6b5e
cmpq %rax, %r15
je 0x6bbc
movq 0x1141d(%rip), %rdi     # 0x17fc8
leaq 0xa593(%rip), %rsi      # 0x11145
movl $0x5, %edx
callq 0x42d0
movq 0x11405(%rip), %rdi     # 0x17fc8
leaq 0xa581(%rip), %rsi      # 0x1114b
movl $0x3, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42d0
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/iterator/BufferIterator.hpp
// Function: BufferIterator<Record>::seek(Record const&)
void seek(const Tuple &k)
    {
      unsigned int d = 1;
      BufferElement<Tuple> high = curr;
      while((high < end) && (*high < k)){
        curr = high;
        high += d;
        d *= 2;
      }
      if(high > end){ high = end; }
      if(curr < high){
        BufferElement<Tuple> temp = lower_bound(curr, high, k);
      }
    }

// Assembly:
movq 0x18(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rax, %rcx
jbe 0x6db8
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rdx
movl $0x1, %esi
cmpq %rdx, (%rax)
jge 0x6db7
movq %rax, 0x18(%rdi)
movl %esi, %r8d
shlq $0x4, %r8
addq %r8, %rax
addl %esi, %esi
cmpq %rcx, %rax
jb 0x6d9d
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/cog/ConcatCog.hpp
// Function: ConcatCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "Concat" << std::endl;
      lhs->printDebug(depth+1);
      rhs->printDebug(depth+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x7f44
leal 0x1(%rbx), %r13d
movq 0x100a4(%rip), %r15     # 0x17fc8
leaq 0x9204(%rip), %r12      # 0x1112f
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r13d
cmpl $0x1, %r13d
ja 0x7f2b
movq 0x1007d(%rip), %r15     # 0x17fc8
leaq 0x926f(%rip), %rsi      # 0x111c1
movl $0x6, %edx
movq %r15, %rdi
callq 0x42d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
movq 0x10(%r14), %r15
incl %ebx
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x7fbb
movq 0x10015(%rip), %rax     # 0x17fc0
cmpb $0x0, (%rax)
je 0x7fb6
incl 0x8(%r15)
jmp 0x7fbb
lock
incl 0x8(%r15)
leaq -0x2a(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r12, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x7fdd
movq %r15, %rdi
callq 0x65c2
movq 0x20(%r14), %r15
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8010
movq 0xffc0(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x800b
incl 0x8(%r15)
jmp 0x8010
lock
incl 0x8(%r15)
leaq -0x2c(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x8031
movq %r15, %rdi
callq 0x65c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8042
movq %rax, %rbx
testq %r15, %r15
je 0x8052
movq %r15, %rdi
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/iterator/MergeIterator.hpp
// Function: MergeIterator<Record>::MergeIterator(std::shared_ptr<CogHandleBase<Record>>, std::shared_ptr<CogHandleBase<Record>>)
MergeIterator(
      CogHandle<Tuple> lhs, 
      CogHandle<Tuple> rhs
    )
    {
      lhsIter = lhs->iterator();
      lhsDone = lhsIter->atEnd();
      rhsIter = rhs->iterator();
      rhsDone = rhsIter->atEnd();
      updateBest();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0xf8ba(%rip), %rax      # 0x17930
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq (%rsi), %r15
leaq -0x22(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x80be
movq 0xff12(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x80b9
incl 0x8(%r15)
jmp 0x80be
lock
incl 0x8(%r15)
leaq -0x22(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
leaq -0x40(%rbp), %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0x80e1
movq %r15, %rdi
callq 0x65c2
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x30(%rbx), %rdi
movups %xmm0, 0x28(%rbx)
testq %rdi, %rdi
je 0x810c
callq 0x65c2
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x810c
callq 0x65c2
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
movq (%r14), %r15
leaq -0x22(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x814b
movq 0xfe85(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x8146
incl 0x8(%r15)
jmp 0x814b
lock
incl 0x8(%r15)
leaq -0x22(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq *(%rax)
testq %r15, %r15
je 0x816d
movq %r15, %rdi
callq 0x65c2
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x40(%rbx), %rdi
movups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0x8198
callq 0x65c2
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x8198
callq 0x65c2
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
movb 0x48(%rbx), %cl
orb %cl, %al
je 0x81b1
xorb $0x1, %cl
jmp 0x81cf
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rcx
cmpq (%rax), %rcx
setl %cl
movb %cl, 0x4a(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x81e1
movq %rax, %r14
testq %r15, %r15
je 0x81f6
movq %r15, %rdi
callq 0x65c2
jmp 0x81f6
movq %rax, %r14
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x8204
callq 0x65c2
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x8212
callq 0x65c2
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x8220
callq 0x65c2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x822e
callq 0x65c2
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/iterator/MergeIterator.hpp
// Function: MergeIterator<Record>::next()
void next()
    {
      if(lhsDone && rhsDone) { return; }
      if(lhsBest) { lhsIter->next(); lhsDone = lhsIter->atEnd(); }
      else        { rhsIter->next(); rhsDone = rhsIter->atEnd(); }
      updateBest();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x48(%rdi)
jne 0x8266
cmpb $0x0, 0x49(%rbx)
jne 0x82d1
cmpb $0x0, 0x4a(%rbx)
je 0x82af
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
testb %al, %al
jne 0x82cc
movb $0x1, %al
cmpb $0x0, 0x49(%rbx)
jne 0x82ce
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq %rax, %r14
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq (%r14), %rcx
cmpq (%rax), %rcx
setl %al
jmp 0x82ce
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
testb $0x1, 0x48(%rbx)
je 0x8287
xorl %eax, %eax
movb %al, 0x4a(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/cog/BTreeCog.hpp
// Function: BTreeCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "BTree[" << sep << "]" << std::endl;
      lhs->printDebug(depth+1);
      rhs->printDebug(depth+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0x88da
leal 0x1(%rbx), %r13d
movq 0xf70e(%rip), %r15      # 0x17fc8
leaq 0x886e(%rip), %r12      # 0x1112f
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r13d
cmpl $0x1, %r13d
ja 0x88c1
movq 0xf6e7(%rip), %r15      # 0x17fc8
leaq 0x88e0(%rip), %rsi      # 0x111c8
movl $0x6, %edx
movq %r15, %rdi
callq 0x42d0
leaq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x486c
movq %rax, %r15
leaq 0x8f29(%rip), %rsi      # 0x11834
movl $0x1, %edx
movq %rax, %rdi
callq 0x42d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
movq 0x20(%r14), %r15
incl %ebx
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8974
movq 0xf65c(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x896f
incl 0x8(%r15)
jmp 0x8974
lock
incl 0x8(%r15)
leaq -0x2a(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r12, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x8996
movq %r15, %rdi
callq 0x65c2
movq 0x30(%r14), %r15
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x89c9
movq 0xf607(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x89c4
incl 0x8(%r15)
jmp 0x89c9
lock
incl 0x8(%r15)
leaq -0x2c(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0x89ea
movq %r15, %rdi
callq 0x65c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x89fb
movq %rax, %rbx
testq %r15, %r15
je 0x8a0b
movq %r15, %rdi
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/iterator/SeqIterator.hpp
// Function: SeqIterator<Record>::seek(Record const&)
void seek(const Tuple &k)
    {
      if(!(k < sep)) { lhsDone = true; }
      // check key first... may not need to init LHS.
      initNeeded();
      if(!lhsDone)     { lhsIter->seek(k); lhsDone = lhsIter->atEnd(); }
      else if(!rhsDone){ rhsIter->seek(k); rhsDone = rhsIter->atEnd(); }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
cmpq 0x50(%rdi), %rax
jl 0x8c54
movb $0x1, 0x48(%rbx)
movq %rbx, %rdi
callq 0x8cb0
cmpb $0x0, 0x48(%rbx)
je 0x8c84
cmpb $0x0, 0x49(%rbx)
jne 0x8c9e
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
jmp 0x8c9e
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/iterator/SeqIterator.hpp
// Function: SeqIterator<Record>::initNeeded()
inline void initNeeded()
    { 
      if(!lhsDone) {
        if(lhsIter.get() == NULL) { 
          lhsIter = lhs->iterator();
          lhsDone = lhsIter->atEnd();
        }
      }
      if(lhsDone)  {
        if(rhsIter.get() == NULL) { 
          rhsIter = rhs->iterator();
          rhsDone = rhsIter->atEnd();
        }
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb 0x48(%rdi), %al
testb %al, %al
jne 0x8d63
cmpq $0x0, 0x28(%rbx)
jne 0x8d63
movq 0x8(%rbx), %r14
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x4340
movq (%r14), %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x8d09
movq 0xf2c7(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x8d04
incl 0x8(%r14)
jmp 0x8d09
lock
incl 0x8(%r14)
leaq -0x30(%rbp), %rdi
callq 0x42e0
movq (%r15), %rax
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq *(%rax)
testq %r14, %r14
je 0x8d2b
movq %r14, %rdi
callq 0x65c2
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x30(%rbx), %rdi
movups %xmm0, 0x28(%rbx)
testq %rdi, %rdi
je 0x8d56
callq 0x65c2
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x8d56
callq 0x65c2
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x48(%rbx)
testb %al, %al
je 0x8e03
cmpq $0x0, 0x38(%rbx)
jne 0x8e03
movq 0x18(%rbx), %r14
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x4340
movq (%r14), %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x8da9
movq 0xf227(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0x8da4
incl 0x8(%r14)
jmp 0x8da9
lock
incl 0x8(%r14)
leaq -0x30(%rbp), %rdi
callq 0x42e0
movq (%r15), %rax
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
callq *(%rax)
testq %r14, %r14
je 0x8dcb
movq %r14, %rdi
callq 0x65c2
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x40(%rbx), %rdi
movups %xmm0, 0x38(%rbx)
testq %rdi, %rdi
je 0x8df6
callq 0x65c2
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x8df6
callq 0x65c2
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movb %al, 0x49(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8e10
movq %rax, %rbx
testq %r14, %r14
je 0x8e20
movq %r14, %rdi
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/src/jitd_tester.cpp
// Function: run_test_thread(JITD<Record, PureLocalPolicy<Record>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void run_test_thread(JITD<Record, JITD_TEST_POLICY> *jitd, string file, int per_op_sleep_ms)
{
  ifstream in(file);
  timeval start, end;
  gettimeofday(&start, NULL);
  cout << "Start[" << file << "]" << endl;
  int t = jitd_test(*jitd, in, false, per_op_sleep_ms);
  gettimeofday(&end, NULL);
  cout << "Time[" << file << "]: " << t << " s" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x248(%rbp), %rdi
movl $0x8, %edx
callq 0x4370
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x4380
movq 0xe9c7(%rip), %rdi      # 0x17fc8
leaq 0x7fef(%rip), %rsi      # 0x115f7
movl $0x6, %edx
callq 0x42d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xe9a8(%rip), %rdi      # 0x17fc8
callq 0x42d0
movq %rax, %r12
leaq 0x8205(%rip), %rsi      # 0x11834
movl $0x1, %edx
movq %rax, %rdi
callq 0x42d0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r12, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
leaq -0x248(%rbp), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %r14d, %ecx
callq 0x9746
movl %eax, %r14d
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x4380
movq 0xe93b(%rip), %rdi      # 0x17fc8
leaq 0x7f6a(%rip), %rsi      # 0x115fe
movl $0x5, %edx
callq 0x42d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xe91c(%rip), %rdi      # 0x17fc8
callq 0x42d0
movq %rax, %rbx
leaq 0x7f49(%rip), %rsi      # 0x11604
movl $0x3, %edx
movq %rax, %rdi
callq 0x42d0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43f0
movq %rax, %rbx
leaq 0x7f2b(%rip), %rsi      # 0x11608
movl $0x2, %edx
movq %rax, %rdi
callq 0x42d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
leaq -0x248(%rbp), %rdi
callq 0x4060
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x972f
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x4060
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/policy/CrackOrSort.hpp
// Function: std::experimental::fundamentals_v1::optional<std::pair<int, std::function<bool (std::shared_ptr<Cog<Record>>&)>>> CrackOrSortArraysBigFirst<Record>(int, std::shared_ptr<Cog<Record>>)
ScoreFunctionReturn<Tuple> CrackOrSortArraysBigFirst(int threshold, CogPtr<Tuple> cog){ 
    if(cog->type != COG_ARRAY){ 
      // std::cerr << "Crack or Sort: Not an Array\n";
      return NO_TRANSFORMS; 
    }
    
    int size = cog->size();
    // std::cerr << "Crack or Sort: Size " << size << " / " << threshold << std::endl;
    // cog->printDebug(3);


    if(size > threshold){
      // std::cerr << "    ^--- Decided on Crack\n";
      return TRANSFORM_WITH(size, randomSplitArray<Tuple>);
    } else {
      // std::cerr << "    ^--- Decided on Sort\n";
      return TRANSFORM_WITH(size, sortArray<Tuple>);
    }

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdx), %rdi
cmpl $0x3, 0x8(%rdi)
jne 0xc1c1
movl %esi, %r14d
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, (%rbx)
leaq 0x2865(%rip), %rcx      # 0xea14
movq %rcx, 0x20(%rbx)
cmpl %r14d, %eax
jle 0xc1d1
leaq 0x20b6(%rip), %rax      # 0xe275
jmp 0xc1d8
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0xc1f3
leaq 0x2556(%rip), %rax      # 0xe72e
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x2837(%rip), %rax      # 0xea22
movq %rax, 0x18(%rbx)
movb $0x1, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/jitd.hpp
// Function: JITD<Record, PureLocalPolicy<Record>>::iterator()
Iterator<Tuple> iterator()
    {
      // Root changes with each version, so we need to sync the pointer.
      CogHandle<Tuple> r = std::atomic_load(&root);
      
      // And grab an iterator on whatever falls out.
      return r->iterator();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x22(%rbp), %rdi
callq 0x4340
movq (%rbx), %r15
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xc6bd
movq 0xb911(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0xc6b9
incl 0x8(%rbx)
jmp 0xc6bd
lock
incl 0x8(%rbx)
leaq -0x22(%rbp), %rdi
callq 0x42e0
leaq -0x24(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xc6f5
movq 0xb8db(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0xc6f0
incl 0x8(%r15)
jmp 0xc6f5
lock
incl 0x8(%r15)
leaq -0x24(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0xc717
movq %r15, %rdi
callq 0x65c2
testq %rbx, %rbx
je 0xc724
movq %rbx, %rdi
callq 0x65c2
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %r15, %r15
je 0xc744
movq %r15, %rdi
callq 0x65c2
testq %rbx, %rbx
je 0xc751
movq %rbx, %rdi
callq 0x65c2
movq %r14, %rdi
callq 0x4400
nop
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/cog/DeleteCog.hpp
// Function: DeleteCog<Record>::printDebug(int)
void printDebug(int depth)
    {
      Cog<Tuple>::printPrefix(depth);
      std::cout << "Delete" << std::endl;
      source->printDebug(depth+1);
      deleted->printDebug(depth+1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xd0a2
leal 0x1(%rbx), %r13d
movq 0xaf46(%rip), %r15      # 0x17fc8
leaq 0x40a6(%rip), %r12      # 0x1112f
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x42d0
decl %r13d
cmpl $0x1, %r13d
ja 0xd089
movq 0xaf1f(%rip), %r15      # 0x17fc8
leaq 0x4800(%rip), %rsi      # 0x118b0
movl $0x6, %edx
movq %r15, %rdi
callq 0x42d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4250
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4190
movq 0x10(%r14), %r15
incl %ebx
leaq -0x2a(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r12
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xd119
movq 0xaeb7(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0xd114
incl 0x8(%r15)
jmp 0xd119
lock
incl 0x8(%r15)
leaq -0x2a(%rbp), %rdi
callq 0x42e0
movq (%r12), %rax
movq %r12, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0xd13b
movq %r15, %rdi
callq 0x65c2
movq 0x20(%r14), %r15
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
callq 0x4340
movq (%r15), %r14
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xd16e
movq 0xae62(%rip), %rax      # 0x17fc0
cmpb $0x0, (%rax)
je 0xd169
incl 0x8(%r15)
jmp 0xd16e
lock
incl 0x8(%r15)
leaq -0x2c(%rbp), %rdi
callq 0x42e0
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
testq %r15, %r15
je 0xd18f
movq %r15, %rdi
callq 0x65c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd1a0
movq %rax, %rbx
testq %r15, %r15
je 0xd1b0
movq %r15, %rdi
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/policy/PureLocalPolicy.hpp
// Function: PureLocalPolicy<Record>::enqueueCog(std::shared_ptr<CogHandleBase<Record>>)
inline void enqueueCog(CogHandle<Tuple> target)
    {
      // std::cerr << "Enqueue " << target << std::endl;
      CogPtr<Tuple> cog = target->get();
      std::experimental::optional<std::pair<Score,Transform<Tuple>>> op = score(cog);
      if(op){
        todos.emplace(
          target,
          op->second,
          op->first
        );        
      }
      cog->apply_to_children(std::bind(&PureLocalPolicy::enqueueCog, this, std::placeholders::_1));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rbx
leaq -0x90(%rbp), %rdi
movq %rbx, %rsi
callq 0x4340
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xd402
movq 0xabca(%rip), %r13      # 0x17fc0
cmpb $0x0, (%r13)
je 0xd41c
incl 0x8(%rbx)
jmp 0xd420
leaq -0x90(%rbp), %rdi
callq 0x42e0
movq %r14, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
jmp 0xd444
lock
incl 0x8(%rbx)
leaq -0x90(%rbp), %rdi
callq 0x42e0
movq %r14, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
cmpb $0x0, (%r13)
je 0xd440
incl 0x8(%rbx)
jmp 0xd444
lock
incl 0x8(%rbx)
cmpq $0x0, 0x30(%r15)
je 0xd52b
leaq 0x20(%r15), %rsi
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq *0x38(%r15)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xd470
callq 0x65c2
cmpb $0x1, -0x68(%rbp)
jne 0xd49b
leaq -0x88(%rbp), %rdx
leaq -0x90(%rbp), %rcx
movq %r15, %rdi
movq %r12, %rsi
callq 0xdb2c
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq 0xdb6a
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
movl $0x18, %edi
callq 0x4270
leaq -0xfd(%rip), %rcx       # 0xd3ba
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq %r15, 0x10(%rax)
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
leaq 0xbba(%rip), %rax       # 0xe08e
movq %rax, 0x18(%rsi)
leaq 0xbc3(%rip), %rax       # 0xe0a2
movq %rax, 0x10(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xd503
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq -0x90(%rbp), %rdi
callq 0xdb00
testq %rbx, %rbx
je 0xd51c
movq %rbx, %rdi
callq 0x65c2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x40d0
jmp 0xd54e
movq %rax, %r14
movq -0x50(%rbp), %rax
testq %rax, %rax
je 0xd55b
leaq -0x60(%rbp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xd55b
movq %rax, %rdi
callq 0x4acd
jmp 0xd558
movq %rax, %r14
leaq -0x90(%rbp), %rdi
callq 0xdb00
jmp 0xd57a
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0xd57a
callq 0x65c2
testq %rbx, %rbx
je 0xd587
movq %rbx, %rdi
callq 0x65c2
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/transform/transform_atomic.hpp
// Function: bool sortArray<Record>(std::shared_ptr<Cog<Record>>&)
bool sortArray(CogPtr<Tuple> &cog)
    {
      if(cog->type == COG_ARRAY){
        ArrayCog<Tuple> *arr = (ArrayCog<Tuple> *)cog.get();
        Buffer<Tuple> sorted = arr->sortedBuffer();
        cog = CogPtr<Tuple>(new SortedArrayCog<Tuple>(
          sorted, sorted->begin(), sorted->end()
        ));
        return true;
      }
      return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rsi
movl 0x8(%rsi), %r15d
cmpl $0x3, %r15d
jne 0xe839
movq %rdi, %r14
leaq -0x28(%rbp), %rdi
callq 0x6be2
movl $0x30, %edi
callq 0x4270
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rbx
testq %rbx, %rbx
je 0xe783
movq 0x984a(%rip), %rdi      # 0x17fc0
cmpb $0x0, (%rdi)
je 0xe7a5
incl 0x8(%rbx)
movq %rcx, %rsi
jmp 0xe7ad
movq (%rcx), %rdx
movq 0x8(%rcx), %rsi
movl $0x4, 0x8(%rax)
leaq 0x90b8(%rip), %rdi      # 0x17850
movq %rdi, (%rax)
movq %rcx, 0x10(%rax)
movq %rbx, 0x18(%rax)
jmp 0xe7db
lock
incl 0x8(%rbx)
movq -0x28(%rbp), %rsi
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movl $0x4, 0x8(%rax)
leaq 0x908e(%rip), %r8       # 0x17850
movq %r8, (%rax)
movq %rcx, 0x10(%rax)
movq %rbx, 0x18(%rax)
cmpb $0x0, (%rdi)
je 0xe7d7
incl 0x8(%rbx)
jmp 0xe7db
lock
incl 0x8(%rbx)
movq %rdx, 0x20(%rax)
movq %rsi, 0x28(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x7650
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x8(%r14), %rdi
movups %xmm0, (%r14)
testq %rdi, %rdi
je 0xe81e
callq 0x65c2
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xe81e
callq 0x65c2
testq %rbx, %rbx
je 0xe82b
movq %rbx, %rdi
callq 0x65c2
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xe839
callq 0x65c2
cmpl $0x3, %r15d
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
testq %rbx, %rbx
je 0xe860
movq %rbx, %rdi
callq 0x65c2
jmp 0xe860
movq %rax, %r14
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0xe86e
callq 0x65c2
movq %r14, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/UBOdin[P]jitd-cpp/include/data.hpp
// Function: std::pair<std::shared_ptr<std::vector<Record, std::allocator<Record>>>, std::shared_ptr<std::vector<Record, std::allocator<Record>>>> splitBuffer<Record>(std::vector<Record, std::allocator<Record>>::const_iterator, std::vector<Record, std::allocator<Record>>::const_iterator, Record const&)
inline std::pair<Buffer<Tuple>,Buffer<Tuple> > 
    splitBuffer(BufferElement<Tuple> curr, 
                BufferElement<Tuple> end, 
                const Tuple &pivot)
  {
    Buffer<Tuple> low (new std::vector<Tuple>);
    Buffer<Tuple> high(new std::vector<Tuple>);
    for(; curr < end; ++curr){
      if(*curr < pivot){ low ->push_back(*curr); }
      else             { high->push_back(*curr); }
    }
    return std::pair<Buffer<Tuple>,Buffer<Tuple> >(low, high);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x18, %edi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x28(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x67c8
movl $0x18, %edi
callq 0x4270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x38(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq %rax, %rsi
callq 0x67c8
cmpq %r15, %r12
jae 0xe951
movq (%r12), %rax
cmpq (%r14), %rax
jge 0xe923
movq -0x30(%rbp), %rdi
jmp 0xe927
movq -0x40(%rbp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xe943
addq $0x8, %rdi
movups (%r12), %xmm0
movups %xmm0, (%rsi)
addq $0x10, (%rdi)
jmp 0xe94b
movq %r12, %rdx
callq 0x68a8
addq $0x10, %r12
jmp 0xe90f
leaq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe9bc
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xe972
callq 0x65c2
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xe980
callq 0x65c2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xe9a6
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0xe9a6
callq 0x65c2
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0xe9b4
callq 0x65c2
movq %rbx, %rdi
callq 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/bendem[P]DiskGraph/src/string_manips.cpp
// Function: humanReadable[abi:cxx11](unsigned int)
pair<float, string> humanReadable(unsigned size) {
    if(size < 1024) {
        return pair<float, string> { size, human_readable_sizes[0] };
    }
    float res = size;
    unsigned i;
    for(i = 1; i < human_readable_sizes.size(); ++i) {
        res /= 1024;
        if(res < 1) {
            break;
        }
    }
    return pair<float, string>{ res*1024, human_readable_sizes[i] };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x4a16
movq 0x4dc8(%rip), %rax      # 0x97d8
cvtsi2ss %esi, %xmm0
jmp 0x4a81
movl %esi, %eax
cvtsi2ss %rax, %xmm0
movq 0x4dbc(%rip), %rdx      # 0x97e0
movq 0x4dad(%rip), %rax      # 0x97d8
subq %rax, %rdx
sarq $0x5, %rdx
movl $0x1, %ecx
cmpq $0x2, %rdx
jb 0x4a72
mulss 0x1723(%rip), %xmm0     # 0x6168
movss 0x171f(%rip), %xmm1     # 0x616c
ucomiss %xmm0, %xmm1
ja 0x4a72
movl $0x2, %esi
movss 0x1709(%rip), %xmm2     # 0x6168
movl %esi, %ecx
cmpq %rcx, %rdx
jbe 0x4a72
mulss %xmm2, %xmm0
leal 0x1(%rcx), %esi
ucomiss %xmm0, %xmm1
jbe 0x4a5f
mulss 0x16f6(%rip), %xmm0     # 0x6170
shlq $0x5, %rcx
addq %rcx, %rax
movss %xmm0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
callq 0x42fa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq