LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image.c
// Function: stbi__png_info_raw
static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp)
{
   if (!stbi__parse_png_file(p, SCAN_header, 0)) {
      stbi__rewind( p->s );
      return 0;
   }
   if (x) *x = p->s->img_x;
   if (y) *y = p->s->img_y;
   if (comp) *comp = p->s->img_n;
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x418720
cmpl $0x0, %eax
jne 0x41e6c2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x414d00
movl $0x0, -0x4(%rbp)
jmp 0x41e70d
cmpq $0x0, -0x18(%rbp)
je 0x41e6d8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x41e6ef
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x41e706
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image_write.c
// Function: outfile
static int outfile(char const *filename, int rgb_dir, int vdir, int x, int y, int comp, void *data, int alpha, int pad, const char *fmt, ...)
{
   FILE *f;
   if (y < 0 || x < 0) return 0;
   f = fopen(filename, "wb");
   if (f) {
      va_list v;
      va_start(v, fmt);
      writefv(f, fmt, v);
      va_end(v);
      write_pixels(f,rgb_dir,vdir,x,y,comp,data,alpha,pad);
      fclose(f);
   }
   return f != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x41e91e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x41e94d
cmpl $0x0, -0x1c(%rbp)
jge 0x41e959
movl $0x0, -0x4(%rbp)
jmp 0x41e9f8
movq -0x10(%rbp), %rdi
leaq 0xc49a1(%rip), %rsi     # 0x4e3305
callq 0x43c8a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x41e9e8
leaq -0x50(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x30, (%rax)
movq -0x30(%rbp), %rdi
movq 0x28(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x4206f0
leaq -0x50(%rbp), %rax
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq 0x10(%rbp), %r11
movl 0x18(%rbp), %r10d
movl 0x20(%rbp), %eax
movq %r11, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x4208e0
movq -0x30(%rbp), %rdi
callq 0x43c170
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image_write.c
// Function: stbiw__sbgrowf
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = realloc(*arr ? stbiw__sbraw(*arr) : 0, itemsize * m + sizeof(int)*2);
   assert(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x41f800
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x8(%rax), %eax
shll %eax
addl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x41f809
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x41f82a
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x41f832
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x41f832
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rsi
addq $0x8, %rsi
callq 0x4533b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41f856
jmp 0x41f875
leaq 0xe6931(%rip), %rdi     # 0x50618e
leaq 0xc6555(%rip), %rsi     # 0x4e5db9
movl $0x8c, %edx
leaq 0xc6644(%rip), %rcx     # 0x4e5eb4
callq 0x42dfd0
cmpq $0x0, -0x20(%rbp)
je 0x41f8ad
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x41f891
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, -0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/stb_image_write.c
// Function: stbi_write_png
int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (!png) return 0;
   f = fopen(filename, "wb");
   if (!f) { free(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   free(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x3c(%rbp), %r9
callq 0x41fb80
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x42068b
movl $0x0, -0x4(%rbp)
jmp 0x4206e7
movq -0x10(%rbp), %rdi
leaq 0xc2c6f(%rip), %rsi     # 0x4e3305
callq 0x43c8a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4206b8
movq -0x48(%rbp), %rdi
callq 0x453060
movl $0x0, -0x4(%rbp)
jmp 0x4206e7
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x43cbf0
movq -0x38(%rbp), %rdi
callq 0x43c170
movq -0x48(%rbp), %rdi
callq 0x453060
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/timer.c
// Function: getRawTime
uint64_t getRawTime() {
  struct timeval tv;

  if(0!=gettimeofday(&tv, 0)) {
    return 0;
  }

  return (uint64_t) tv.tv_sec * (uint64_t) 1000000 + (uint64_t) tv.tv_usec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x48e950
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x420ba7
movq $0x0, -0x8(%rbp)
jmp 0x420bb7
imulq $0xf4240, -0x18(%rbp), %rax # imm = 0xF4240
addq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/timer.c
// Function: timer
double timer() {
  static bool inited=false;
  static uint64_t start;
  uint64_t stop, dif;

  if(!inited) {
    start=getRawTime();
    inited=true;
  }

  stop=getRawTime();
  dif=stop-start;
  return dif/1000000.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x1092f1(%rip)    # 0x529ed0
jne 0x420bf4
callq 0x420b80
movq %rax, 0x1092eb(%rip)    # 0x529ed8
movb $0x1, 0x1092dc(%rip)    # 0x529ed0
callq 0x420b80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x1092d0(%rip), %rcx    # 0x529ed8
subq %rcx, %rax
movq %rax, -0x10(%rbp)
movaps 0xc52da(%rip), %xmm1    # 0x4e5ef0
movq -0x10(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc52d9(%rip), %xmm1    # 0x4e5f00
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xc23da(%rip), %xmm1    # 0x4e3018
divsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinycthread.c
// Function: cnd_timedwait
int cnd_timedwait(cnd_t *cond, mtx_t *mtx, const struct timespec *ts)
{
#if defined(_TTHREAD_WIN32_)
  struct timespec now;
  if (timespec_get(&now, TIME_UTC) == 0)
  {
    DWORD delta = (DWORD)((ts->tv_sec - now.tv_sec) * 1000 +
      (ts->tv_nsec - now.tv_nsec + 500000) / 1000000); //modified, added cast
    return _cnd_timedwait_win32(cond, mtx, delta);
  }
  else
    return thrd_error;
#else
  int ret;
  ret = pthread_cond_timedwait(cond, mtx, ts);
  if (ret == ETIMEDOUT)
  {
    return thrd_timedout;
  }
  return ret == 0 ? thrd_success : thrd_error;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x448190
movl %eax, -0x24(%rbp)
cmpl $0x6e, -0x24(%rbp)
jne 0x420ee7
movl $0x2, -0x4(%rbp)
jmp 0x420efa
movl -0x24(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinycthread.c
// Function: thrd_create
int thrd_create(thrd_t *thr, thrd_start_t func, void *arg)
{
  /* Fill out the thread startup information (passed to the thread wrapper,
     which will eventually free it) */
  _thread_start_info* ti = (_thread_start_info*)malloc(sizeof(_thread_start_info));
  if (ti == NULL)
  {
    return thrd_nomem;
  }
  ti->mFunction = func;
  ti->mArg = arg;

  /* Create the thread */
#if defined(_TTHREAD_WIN32_)
  *thr = CreateThread(NULL, 0, _thrd_wrapper_function, (LPVOID) ti, 0, NULL);
#elif defined(_TTHREAD_POSIX_)
  if(pthread_create(thr, NULL, _thrd_wrapper_function, (void *)ti) != 0)
  {
    *thr = 0;
  }
#endif

  /* Did we fail to create the thread? */
  if(!*thr)
  {
    free(ti);
    return thrd_error;
  }

  return thrd_success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x10, %edi
callq 0x452d20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x420f42
movl $0x4, -0x4(%rbp)
jmp 0x420fa4
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x44(%rip), %rdx        # 0x420fb0
callq 0x4490f0
cmpl $0x0, %eax
je 0x420f81
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x420f9d
movq -0x28(%rbp), %rdi
callq 0x453060
movl $0x0, -0x4(%rbp)
jmp 0x420fa4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_open
_TINYDIR_FUNC
int tinydir_open(tinydir_dir *dir, const char *path)
{
	if (dir == NULL || path == NULL || strlen(path) == 0)
	{
		errno = EINVAL;
		return -1;
	}
	if (strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX)
	{
		errno = ENAMETOOLONG;
		return -1;
	}

	/* initialise dir */
	dir->_files = NULL;
#ifdef _MSC_VER
	dir->_h = INVALID_HANDLE_VALUE;
#else
	dir->_d = NULL;
#endif
	tinydir_close(dir);

	strcpy(dir->path, path);
#ifdef _MSC_VER
	strcat(dir->path, "\\*");

  /*modified start*/
#ifdef UNICODE
  wchar_t path2[512];
  MultiByteToWideChar(CP_ACP,0,dir->path,-1,path2,512);
  dir->_h = FindFirstFile(path2, &dir->_f);
#else
	dir->_h = FindFirstFile(dir->path, &dir->_f); //same
#endif
  /*modified end*/
	dir->path[strlen(dir->path) - 2] = '\0';
	if (dir->_h == INVALID_HANDLE_VALUE)
#else
	dir->_d = opendir(path);
	if (dir->_d == NULL)
#endif
	{
		errno = ENOENT;
		goto bail;
	}

	/* read first file */
	dir->has_next = 1;
#ifndef _MSC_VER
	dir->_e = readdir(dir->_d);
	if (dir->_e == NULL)
	{
		dir->has_next = 0;
	}
#endif

	return 0;

bail:
	tinydir_close(dir);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42126d
cmpq $0x0, -0x18(%rbp)
je 0x42126d
movq -0x18(%rbp), %rdi
callq 0x401138
cmpq $0x0, %rax
jne 0x421284
callq 0x42de60
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421377
movq -0x18(%rbp), %rdi
callq 0x401138
addq $0x0, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jb 0x4212b0
callq 0x42de60
movl $0x24, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421377
movq -0x10(%rbp), %rax
movq $0x0, 0x1010(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x1018(%rax)
movq -0x10(%rbp), %rdi
callq 0x421380
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x401020
movq -0x18(%rbp), %rdi
callq 0x48ebb0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1018(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1018(%rax)
jne 0x421316
callq 0x42de60
movl $0x2, (%rax)
jmp 0x421367
movq -0x10(%rbp), %rax
movl $0x1, 0x1000(%rax)
movq -0x10(%rbp), %rax
movq 0x1018(%rax), %rdi
callq 0x48ee10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1020(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1020(%rax)
jne 0x42135e
movq -0x10(%rbp), %rax
movl $0x0, 0x1000(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x421377
movq -0x10(%rbp), %rdi
callq 0x421380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_close
_TINYDIR_FUNC
void tinydir_close(tinydir_dir *dir)
{
	if (dir == NULL)
	{
		return;
	}

	memset(dir->path, 0, sizeof(dir->path));
	dir->has_next = 0;
	dir->n_files = 0;
	if (dir->_files != NULL)
	{
		free(dir->_files);
	}
	dir->_files = NULL;
#ifdef _MSC_VER
	if (dir->_h != INVALID_HANDLE_VALUE)
	{
		FindClose(dir->_h);
	}
	dir->_h = INVALID_HANDLE_VALUE;
#else
	if (dir->_d)
	{
		closedir(dir->_d);
	}
	dir->_d = NULL;
	dir->_e = NULL;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x421398
jmp 0x42142e
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x4010e0
movq -0x8(%rbp), %rax
movl $0x0, 0x1000(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1008(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1010(%rax)
je 0x4213e3
movq -0x8(%rbp), %rax
movq 0x1010(%rax), %rdi
callq 0x453060
movq -0x8(%rbp), %rax
movq $0x0, 0x1010(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x1018(%rax)
je 0x421410
movq -0x8(%rbp), %rax
movq 0x1018(%rax), %rdi
callq 0x48ede0
movq -0x8(%rbp), %rax
movq $0x0, 0x1018(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1020(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_next
_TINYDIR_FUNC
int tinydir_next(tinydir_dir *dir)
{
	if (dir == NULL)
	{
		errno = EINVAL;
		return -1;
	}
	if (!dir->has_next)
	{
		errno = ENOENT;
		return -1;
	}

#ifdef _MSC_VER
	if (FindNextFile(dir->_h, &dir->_f) == 0)
#else
	dir->_e = readdir(dir->_d);
	if (dir->_e == NULL)
#endif
	{
		dir->has_next = 0;
#ifdef _MSC_VER
		if (GetLastError() != ERROR_SUCCESS &&
			GetLastError() != ERROR_NO_MORE_FILES)
		{
			tinydir_close(dir);
			errno = EIO;
			return -1;
		}
#endif
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x421617
callq 0x42de60
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421679
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1000(%rax)
jne 0x421638
callq 0x42de60
movl $0x2, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421679
movq -0x10(%rbp), %rax
movq 0x1018(%rax), %rdi
callq 0x48ee10
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1020(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x1020(%rax)
jne 0x421672
movq -0x10(%rbp), %rax
movl $0x0, 0x1000(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_file_cmp
_TINYDIR_FUNC
int _tinydir_file_cmp(const void *a, const void *b)
{
	const tinydir_file *fa = (const tinydir_file *)a;
	const tinydir_file *fb = (const tinydir_file *)b;
	if (fa->is_dir != fb->is_dir)
	{
		return -(fa->is_dir - fb->is_dir);
	}
	return strncmp(fa->name, fb->name, _TINYDIR_FILENAME_MAX);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x1108(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x1108(%rcx), %eax
je 0x4218a3
movq -0x20(%rbp), %rax
movl 0x1108(%rax), %ecx
movq -0x28(%rbp), %rax
subl 0x1108(%rax), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4218c6
movq -0x20(%rbp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
movq -0x28(%rbp), %rsi
addq $0x1000, %rsi           # imm = 0x1000
movl $0x100, %edx            # imm = 0x100
callq 0x4010b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_get_ext
_TINYDIR_FUNC
void _tinydir_get_ext(tinydir_file *file)
{
	char *period = strrchr(file->name, '.');
	if (period == NULL)
	{
		file->extension = &(file->name[strlen(file->name)]);
	}
	else
	{
		file->extension = period + 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
movl $0x2e, %esi
callq 0x401080
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x42192e
movq -0x8(%rbp), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
callq 0x401138
movq -0x18(%rbp), %rcx
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1100(%rax)
jmp 0x421941
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x1100(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_readfile_n
_TINYDIR_FUNC
int tinydir_readfile_n(const tinydir_dir *dir, tinydir_file *file, size_t i)
{
	if (dir == NULL || file == NULL)
	{
		errno = EINVAL;
		return -1;
	}
	if (i >= dir->n_files)
	{
		errno = ENOENT;
		return -1;
	}

	memcpy(file, &dir->_files[i], sizeof(tinydir_file));
	_tinydir_get_ext(file);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x421972
cmpq $0x0, -0x18(%rbp)
jne 0x421986
callq 0x42de60
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4219df
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1008(%rcx), %rax
jb 0x4219ab
callq 0x42de60
movl $0x2, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4219df
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x1010(%rax), %rsi
imulq $0x11a0, -0x20(%rbp), %rax # imm = 0x11A0
addq %rax, %rsi
movl $0x11a0, %edx           # imm = 0x11A0
callq 0x401058
movq -0x18(%rbp), %rdi
callq 0x4218d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/tinydir.c
// Function: tinydir_open_subdir_n
_TINYDIR_FUNC
int tinydir_open_subdir_n(tinydir_dir *dir, size_t i)
{
	char path[_TINYDIR_PATH_MAX];
	if (dir == NULL)
	{
		errno = EINVAL;
		return -1;
	}
	if (i >= dir->n_files || !dir->_files[i].is_dir)
	{
		errno = ENOENT;
		return -1;
	}

	strcpy(path, dir->_files[i].path);
	tinydir_close(dir);
	if (tinydir_open_sorted(dir, path) == -1)
	{
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x421a21
callq 0x42de60
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421ab5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x1008(%rcx), %rax
jae 0x421a51
movq -0x10(%rbp), %rax
movq 0x1010(%rax), %rax
imulq $0x11a0, -0x18(%rbp), %rcx # imm = 0x11A0
addq %rcx, %rax
cmpl $0x0, 0x1108(%rax)
jne 0x421a65
callq 0x42de60
movl $0x2, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421ab5
leaq -0x1020(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x1010(%rax), %rsi
imulq $0x11a0, -0x18(%rbp), %rax # imm = 0x11A0
addq %rax, %rsi
callq 0x401020
movq -0x10(%rbp), %rdi
callq 0x421380
movq -0x10(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x421440
cmpl $-0x1, %eax
jne 0x421aae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x421ab5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: intersectKdtree_test
bool intersectKdtree_test(const float *rayOrigin,const float *rayVec,
                     const float *minBound,const float *maxBound,
                     struct KdTraverseNode *stack,
                     const struct KdNode *rootNode,
                     float *t2,float *colPt2,int *primInd,
                     float *bcOut,
                     const struct Triangle *triangles,int trianglesNum,
                     const struct Sphere *spheres,int spheresNum) {

  //todo: test all objects
  return intersectKdtree(rayOrigin,rayVec,minBound,maxBound,
                              stack,rootNode,t2,colPt2,primInd,bcOut,
                              triangles,trianglesNum,spheres,spheresNum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl 0x48(%rbp), %eax
movq 0x40(%rbp), %rax
movl 0x38(%rbp), %eax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %r9, -0x58(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x58(%rbp), %r9
movq 0x10(%rbp), %r13
movq 0x18(%rbp), %r12
movq 0x20(%rbp), %r15
movq 0x28(%rbp), %r14
movq 0x30(%rbp), %rbx
movl 0x38(%rbp), %r11d
movq 0x40(%rbp), %r10
movl 0x48(%rbp), %eax
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movl %eax, 0x38(%rsp)
callq 0x421e80
andb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: lastFileNum
int lastFileNum(const char *folderName) {
  int num=-1;
  tinydir_dir dir;

  if(tinydir_open(&dir, folderName) != -1) {
    while(dir.has_next) {
      tinydir_file file;
      tinydir_readfile(&dir,&file);
      int fnLen=strlen(file.name);

      char numStr[256];
      numStr[0]='\0';
      memset(numStr,0,256);
      if(!file.is_dir) {
        int i,j=0;

        for(i=0;i<fnLen;i++) {

          // if(file.name[i]=='0' && j==0) {
          //   j++;
          // } else
          if(file.name[i]>='0' && file.name[i]<='9') {
            numStr[j++]=file.name[i];

          } else if(j>0) {
            break;
          }
        }

        if(numStr[0]!='\0') {
          // printf("%s\n",numStr);
          int num2=atoi(numStr);

          if(num2 > num) {
            num=num2;
          }
        }
      }

      tinydir_next(&dir);
    }

    tinydir_close(&dir);
  }

  return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x22f0, %rsp           # imm = 0x22F0
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rsi
leaq -0x1038(%rbp), %rdi
callq 0x421240
cmpl $-0x1, %eax
je 0x424755
jmp 0x424611
cmpl $0x0, -0x38(%rbp)
je 0x424749
leaq -0x1038(%rbp), %rdi
leaq -0x21d8(%rbp), %rsi
callq 0x421690
leaq -0x21d8(%rbp), %rdi
addq $0x1000, %rdi           # imm = 0x1000
callq 0x401138
movl %eax, -0x21dc(%rbp)
movb $0x0, -0x22e0(%rbp)
leaq -0x22e0(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x4010e0
cmpl $0x0, -0x10d0(%rbp)
jne 0x424738
movl $0x0, -0x22e8(%rbp)
movl $0x0, -0x22e4(%rbp)
movl -0x22e4(%rbp), %eax
cmpl -0x21dc(%rbp), %eax
jge 0x424702
movslq -0x22e4(%rbp), %rax
movsbl -0x11d8(%rbp,%rax), %eax
cmpl $0x30, %eax
jl 0x4246e2
movslq -0x22e4(%rbp), %rax
movsbl -0x11d8(%rbp,%rax), %eax
cmpl $0x39, %eax
jg 0x4246e2
movslq -0x22e4(%rbp), %rax
movb -0x11d8(%rbp,%rax), %cl
movl -0x22e8(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x22e8(%rbp)
cltq
movb %cl, -0x22e0(%rbp,%rax)
jmp 0x4246ef
cmpl $0x0, -0x22e8(%rbp)
jle 0x4246ed
jmp 0x424702
jmp 0x4246ef
jmp 0x4246f1
movl -0x22e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22e4(%rbp)
jmp 0x424682
movsbl -0x22e0(%rbp), %eax
cmpl $0x0, %eax
je 0x424736
leaq -0x22e0(%rbp), %rdi
callq 0x433b90
movl %eax, -0x22ec(%rbp)
movl -0x22ec(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x424734
movl -0x22ec(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x424736
jmp 0x424738
leaq -0x1038(%rbp), %rdi
callq 0x4215f0
jmp 0x424611
leaq -0x1038(%rbp), %rdi
callq 0x421380
movl -0xc(%rbp), %eax
addq $0x22f0, %rsp           # imm = 0x22F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: DecodeFloatRGBA
float DecodeFloatRGBA(const float *rgba) {
  //dot(rgba, vec4(1.0,1.0/255.0,1.0/65025.0,1.0/16581375.0));
  float x=rgba[0];
  float y=rgba[1]/255.0f;
  float z=rgba[2]/65025.0f;
  float w=rgba[3]/16581375.0f;
  return x+y+z+w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movss 0xc0a9a(%rip), %xmm1    # 0x4e5270
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0xc1738(%rip), %xmm1    # 0x4e5f28
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movss 0xc(%rax), %xmm0
movss 0xc171a(%rip), %xmm1    # 0x4e5f24
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
addss -0x10(%rbp), %xmm0
addss -0x14(%rbp), %xmm0
addss -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: EncodeFloatRGBA
void EncodeFloatRGBA(float v,float *out) {
//from aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
  // 255^0 = 1
  // 255^1 = 255
  // 255^2 = 65025
  // 255^3 = 16581375

  float enc[4];

  //vec4 enc = vec4(1.0, 255.0, 65025.0, 16581375.0) * v;
  enc[0]=v;
  enc[1]=v*255.0f;
  enc[2]=v*65025.0f;
  enc[3]=v*16581375.0f;

  //enc-=floor(enc); //enc = frac(enc);
  enc[0]-=floor(enc[0]);
  enc[1]-=floor(enc[1]);
  enc[2]-=floor(enc[2]);
  enc[3]-=floor(enc[3]);

  //enc -= enc.yzww * vec4(1.0/255.0,1.0/255.0,1.0/255.0,0.0);
  out[0]=enc[0]-enc[1]*(1.0f/255.0f);
  out[1]=enc[1]-enc[2]*(1.0f/255.0f);
  out[2]=enc[2]-enc[3]*(1.0f/255.0f);
  out[3]=enc[3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x14(%rbp)
movq %rdi, -0x20(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
movss 0xc0a1d(%rip), %xmm0    # 0x4e5270
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0xc16c3(%rip), %xmm0    # 0x4e5f28
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss 0xc16ad(%rip), %xmm0    # 0x4e5f24
mulss -0x14(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x401148
movaps %xmm0, %xmm1
movss -0x30(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x401148
movaps %xmm0, %xmm1
movss -0x2c(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
callq 0x401148
movaps %xmm0, %xmm1
movss -0x28(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x24(%rbp), %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
callq 0x401148
movaps %xmm0, %xmm1
movss -0x24(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x30(%rbp), %xmm1
movss -0x2c(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0xc15f8(%rip), %xmm2    # 0x4e5f2c
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movss -0x2c(%rbp), %xmm1
movss -0x28(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0xc15c9(%rip), %xmm2    # 0x4e5f2c
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x28(%rbp), %xmm1
movss -0x24(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0xc1599(%rip), %xmm2    # 0x4e5f2c
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x24(%rbp), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, 0xc(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: EncodeFloatRG
void EncodeFloatRG(float v, float *out) {
  // vec2 kEncodeMul = vec2( 1.0, 255.0);
  float kEncodeMul[2];
  kEncodeMul[0]=1.0f;
  kEncodeMul[1]=255.0f;

  //
  float kEncodeBit = 0.00392157f;

  //
  float enc[2];

  // enc = (kEncodeMul * v);
  enc[0]=kEncodeMul[0]*v;
  enc[1]=kEncodeMul[1]*v;

  //enc = fract( enc );
  enc[0]-=floor(enc[0]);
  enc[1]-=floor(enc[1]);


  // enc.x  -= (enc.y  * kEncodeBit);
  enc[0]-=enc[1]*kEncodeBit;

  out[0]=enc[0];
  out[1]=enc[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movss 0xbeaab(%rip), %xmm0    # 0x4e3484
movss %xmm0, -0x20(%rbp)
movss 0xc088a(%rip), %xmm0    # 0x4e5270
movss %xmm0, -0x1c(%rbp)
movss 0xc153d(%rip), %xmm0    # 0x4e5f30
movss %xmm0, -0x24(%rbp)
movss -0x20(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x1c(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x2c(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x401148
movaps %xmm0, %xmm1
movss -0x2c(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x401148
movaps %xmm0, %xmm1
movss -0x28(%rbp), %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x24(%rbp), %xmm2
movss -0x2c(%rbp), %xmm1
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movss -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: encodeNorSphereMap
void encodeNorSphereMap(const float *n,float *out) {
  //from aras-p.info/texts/CompactNormalStorage.html
  float f = sqrt(8.0f*n[2]+8.0f);
  out[0]=n[0]/ f + 0.5f;
  out[1]=n[1]/ f + 0.5f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
movss 0xbfe4b(%rip), %xmm1    # 0x4e491c
mulss %xmm1, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x4267b0
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
divss -0x1c(%rbp), %xmm0
movss 0xbe962(%rip), %xmm1    # 0x4e3464
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x10(%rbp), %rax
movss 0x4(%rax), %xmm0
divss -0x1c(%rbp), %xmm0
movss 0xbe940(%rip), %xmm1    # 0x4e3464
addss %xmm1, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: decodeNorSphereMap
void decodeNorSphereMap(const float *enc,float *out) {
  float fenc[2];
  fenc[0]=enc[0]*4.0f-2.0f;
  fenc[1]=enc[1]*4.0f-2.0f;

  float f = fenc[0]*fenc[0]+fenc[1]+fenc[1];
  float g = sqrtf(1.0f-f/4.0f);


  out[0]=fenc[0]*g;
  out[1]=fenc[1]*g;
  out[2]=1.0f-f/2.0f;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movss 0xbfd74(%rip), %xmm1    # 0x4e4914
mulss %xmm1, %xmm0
movss 0xc005c(%rip), %xmm1    # 0x4e4c08
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movss 0xbfd4e(%rip), %xmm1    # 0x4e4914
mulss %xmm1, %xmm0
movss 0xc0036(%rip), %xmm1    # 0x4e4c08
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x18(%rbp), %xmm0
movss -0x18(%rbp), %xmm2
movss -0x14(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
addss -0x14(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm1
movss 0xbfd0b(%rip), %xmm0    # 0x4e4914
divss %xmm0, %xmm1
movss 0xbe86f(%rip), %xmm0    # 0x4e3484
subss %xmm1, %xmm0
callq 0x4267b0
movss %xmm0, -0x20(%rbp)
movss -0x18(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movss -0x14(%rbp), %xmm0
mulss -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movss -0x1c(%rbp), %xmm1
movss 0xbfcb7(%rip), %xmm0    # 0x4e490c
divss %xmm0, %xmm1
movss 0xbe823(%rip), %xmm0    # 0x4e3484
subss %xmm1, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: bitmapFlipVertical
void bitmapFlipVertical(unsigned char *data,int c, int w, int h) {
  unsigned char *tmp;
  tmp=(unsigned char*)malloc(w*c);
  int i;

  for(i=0;i<h/2;i++) {
    int x=i*c*w;
    int y=(h-1-i)*c*w;
    memcpy(tmp,&data[x],c*w);
    memcpy(&data[x],&data[y],c*w);
    memcpy(&data[y],tmp,c*w);
  }

  free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movslq %eax, %rdi
callq 0x452d20
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0x424d5e
movl -0x24(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
subl -0x24(%rbp), %eax
imull -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0x28(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdx
callq 0x401058
movq -0x8(%rbp), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdx
callq 0x401058
movq -0x8(%rbp), %rdi
movslq -0x2c(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
movslq %eax, %rdx
callq 0x401058
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x424caf
movq -0x20(%rbp), %rdi
callq 0x453060
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/archer1357[P]Offline-Raytracer/utils.c
// Function: stringFromFile
bool stringFromFile(const char *fn, char **str) {
  FILE *file;
  unsigned int dataSize;

  //open file
  file = fopen(fn, "rb");

  if(!file) {
    return false;
  }

  //get data size
  fseek(file,0L,SEEK_END);
  dataSize = ftell(file);
  fseek(file,0L,SEEK_SET);

  //
  (*str)=(char*)malloc(dataSize+1);

  //read data
  (*str)[dataSize]=0;//is not already null terminated?
  fread((*str),1,dataSize,file);

  //close file
  fclose(file);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xbfc50(%rip), %rsi     # 0x4e49db
callq 0x43c8a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x424da1
movb $0x0, -0x1(%rbp)
jmp 0x424e1c
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x440980
movq -0x20(%rbp), %rdi
callq 0x43caa0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x440980
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x452d20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x43c9a0
movq -0x20(%rbp), %rdi
callq 0x43c170
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/test_host.c
// Function: main
int
main(int argc VL_UNUSED, char ** argv VL_UNUSED)
{
  char * string = vl_configuration_to_string_copy() ;
  assert (string) ;
  VL_PRINTF(string) ;
  vl_free(string) ;
  return 0 ;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
callq 0x1040
movq %rax, (%rsp)
callq 0x1030
movq %rax, %rcx
movq (%rsp), %rdi
movb $0x0, %al
callq *%rcx
movq (%rsp), %rdi
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: fatal_error
void
fatal_error(char *s)
{
	fprintf(stderr, "%s,%d: error: %s\n", filename, lineno, s);
	fprintf(stderr, "line: %s\n", ibuf);

	if (misra_rules > 1) show_violations();
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xfd35(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq 0xfe23(%rip), %rdx      # 0x140f0
movl 0x10cbd(%rip), %ecx     # 0x14f90
movq -0x8(%rbp), %r8
leaq 0x9143(%rip), %rsi      # 0xd421
movb $0x0, %al
callq 0x4110
movq 0xfd0c(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
leaq 0xd0f9(%rip), %rsi      # 0x113ef
leaq 0x13283(%rip), %rdx     # 0x17580
movb $0x0, %al
callq 0x4110
cmpl $0x1, 0x10c89(%rip)     # 0x14f94
jle 0x4312
callq 0xcc00
movl $0x1, %edi
callq 0x4180
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: emalloc
char *
emalloc(int n)
{	char *ptr;
#ifdef PC
	int m = n%sizeof(unsigned long);
	if (m != 0) n += sizeof(unsigned long)-m;
#endif
	ptr = (char *) malloc(n);
	if (!ptr) fatal_error("out of memory");
	memset(ptr, 0, n);
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rdi
callq 0x4120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x434b
leaq 0x90ed(%rip), %rdi      # 0xd433
callq 0x42b0
movq -0x10(%rbp), %rdi
movslq -0x4(%rbp), %rdx
xorl %esi, %esi
callq 0x40d0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: skipwhite
void
skipwhite(void)
{
	white = 0;
	while (*nowc == ' ' || *nowc == '\t')
	{	if (*nowc == ' ')
			white++;
		else
			white += 8-((nowc - lbuf + white)%8);
		nowc++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x108fa(%rip)     # 0x14f98
movq 0x108fb(%rip), %rax     # 0x14fa0
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1(%rbp)
je 0x46c5
movq 0x108e7(%rip), %rax     # 0x14fa0
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x46ce
jmp 0x4742
movq 0x108cb(%rip), %rax     # 0x14fa0
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x46ee
movl 0x108b5(%rip), %eax     # 0x14f98
addl $0x1, %eax
movl %eax, 0x108ac(%rip)     # 0x14f98
jmp 0x472b
movq 0x108ab(%rip), %rax     # 0x14fa0
leaq 0x108b4(%rip), %rcx     # 0x14fb0
subq %rcx, %rax
movslq 0x10892(%rip), %rcx     # 0x14f98
addq %rcx, %rax
movl $0x8, %ecx
cqto
idivq %rcx
movl $0x8, %ecx
subq %rdx, %rcx
movslq 0x10876(%rip), %rax     # 0x14f98
addq %rcx, %rax
movl %eax, 0x1086d(%rip)     # 0x14f98
movq 0x1086e(%rip), %rax     # 0x14fa0
addq $0x1, %rax
movq %rax, 0x10863(%rip)     # 0x14fa0
jmp 0x469e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: show_line
void
show_line(int d, FILE *fd)
{
	if (verbose)
		fprintf(fd, "[%d:%d] ", level, not_printing[level]);
	if (numbered)
		fprintf(fd, "%s,%d: ", filename, lineno);
	if (verbose || explanations
	|| (!d && !not_printing[level]))	/* not a directive */
	{	prep_line(start);
		fprintf(fd, "%s", lbuf);
	}
	fprintf(fd, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x1184a(%rip)     # 0x15fb0
je 0x4791
movq -0x10(%rbp), %rdi
movl 0x11842(%rip), %edx     # 0x15fb4
movslq 0x1183b(%rip), %rcx     # 0x15fb4
leaq 0x11840(%rip), %rax     # 0x15fc0
movl (%rax,%rcx,4), %ecx
leaq 0x8d71(%rip), %rsi      # 0xd4fb
movb $0x0, %al
callq 0x4110
cmpl $0x0, 0x11c28(%rip)     # 0x163c0
je 0x47b9
movq -0x10(%rbp), %rdi
movq 0xf94b(%rip), %rdx      # 0x140f0
movl 0x107e5(%rip), %ecx     # 0x14f90
leaq 0x8d52(%rip), %rsi      # 0xd504
movb $0x0, %al
callq 0x4110
cmpl $0x0, 0x117f0(%rip)     # 0x15fb0
jne 0x47e5
cmpl $0x0, 0x11bfb(%rip)     # 0x163c4
jne 0x47e5
cmpl $0x0, -0x4(%rbp)
jne 0x480a
movslq 0x117dc(%rip), %rcx     # 0x15fb4
leaq 0x117e1(%rip), %rax     # 0x15fc0
cmpl $0x0, (%rax,%rcx,4)
jne 0x480a
movq 0x11bdc(%rip), %rdi     # 0x163c8
callq 0x4830
movq -0x10(%rbp), %rdi
leaq 0xc41e(%rip), %rsi      # 0x10c1a
leaq 0x107ad(%rip), %rdx     # 0x14fb0
movb $0x0, %al
callq 0x4110
movq -0x10(%rbp), %rdi
leaq 0xc801(%rip), %rsi      # 0x11016
movb $0x0, %al
callq 0x4110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: release_all
static void
release_all(TS *s)
{
	if (!s) return;
	release_all(s->nxt);
	release_ml(s->ml);
	s->nxt = free_ts;
	free_ts = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4c75
jmp 0x4ca9
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x4c60
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x58b0
movq 0x1176a(%rip), %rcx     # 0x16400
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x11757(%rip)     # 0x16400
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: macro_expansion
static void
macro_expansion(void)
{	TS *s;
	MD *m;
	int count = 1, o_count = 0;

	while (count > o_count)
	{	o_count = count;
		prep_line(start);

		if (debugging) printf("%s,%d: Pass %d: <%s>\n",
			filename, lineno, count, lbuf);

		strcpy(sbuf, lbuf);
		for (s = start; s; s = s?s->nxt:s)
			if (s->tok == NAME
			&&  (m = is_macro(s->name)) != NULL)
			{	s = expand_macro(s, m);
				prep_line(start);
				if (strcmp(lbuf, sbuf) != 0)
				{	count++;
					break;	/* start over */
	}		}	}

	if (debugging) printf("Done: <%s>\n", lbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x501e
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq 0x11499(%rip), %rdi     # 0x163c8
callq 0x4830
cmpl $0x0, 0x114a5(%rip)     # 0x163e0
je 0x4f62
movq 0xf1ac(%rip), %rsi      # 0x140f0
movl 0x10046(%rip), %edx     # 0x14f90
movl -0x14(%rbp), %ecx
leaq 0xbfae(%rip), %rdi      # 0x10f02
leaq 0x10055(%rip), %r8      # 0x14fb0
movb $0x0, %al
callq 0x40a0
leaq 0x114d7(%rip), %rdi     # 0x16440
leaq 0x10040(%rip), %rsi     # 0x14fb0
callq 0x4060
movq 0x1144c(%rip), %rax     # 0x163c8
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5019
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x4fed
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7130
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x4fed
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7e10
movq %rax, -0x8(%rbp)
movq 0x11405(%rip), %rdi     # 0x163c8
callq 0x4830
leaq 0xffe1(%rip), %rdi      # 0x14fb0
leaq 0x1146a(%rip), %rsi     # 0x16440
callq 0x4100
cmpl $0x0, %eax
je 0x4feb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5019
jmp 0x4fed
jmp 0x4fef
cmpq $0x0, -0x8(%rbp)
je 0x5004
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x500c
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f80
jmp 0x4f16
cmpl $0x0, 0x113bb(%rip)     # 0x163e0
je 0x503c
leaq 0xbeea(%rip), %rdi      # 0x10f18
leaq 0xff7b(%rip), %rsi      # 0x14fb0
movb $0x0, %al
callq 0x40a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]gh_cpp/Src/gh_cpp1.c
// Function: post_expansion
static void
post_expansion(void)	/* process directives that need macro-expansion first */
{	TS *s;

	if (start && start->tok == CHAR && start->val == '#')
	{	s = start->nxt;
		if (s->tok == NAME)
		{	if (strcmp(s->name, "if") == 0)
				do_if_post();
			else if (strcmp(s->name, "elif") == 0)
				do_elif_post();
			else if (strcmp(s->name, "line") == 0)
				do_lineno(s->nxt);
	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x11368(%rip)     # 0x163c8
je 0x510d
movq 0x1135b(%rip), %rax     # 0x163c8
cmpl $0x2, (%rax)
jne 0x510d
movq 0x1134b(%rip), %rax     # 0x163c8
cmpl $0x23, 0x4(%rax)
jne 0x510d
movq 0x1133a(%rip), %rax     # 0x163c8
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x510b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xbe51(%rip), %rsi      # 0x10eff
callq 0x4100
cmpl $0x0, %eax
jne 0x50bf
callq 0xa080
jmp 0x5109
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xbb6a(%rip), %rsi      # 0x10c38
callq 0x4100
cmpl $0x0, %eax
jne 0x50df
callq 0xa0f0
jmp 0x5107
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x835a(%rip), %rsi      # 0xd448
callq 0x4100
cmpl $0x0, %eax
jne 0x5105
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x6930
jmp 0x5107
jmp 0x5109
jmp 0x510b
jmp 0x510d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)