LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_open_input_file
avi_t *AVI_open_input_file(const char *filename, int getIndex)
{
  avi_t *AVI=NULL;

  /* Create avi_t structure */

  AVI = (avi_t *) malloc(sizeof(avi_t));
  if(AVI==NULL)
    {
      AVI_errno = AVI_ERR_NO_MEM;
      return 0;
    }
  memset((void *)AVI,0,sizeof(avi_t));

  AVI->mode = AVI_MODE_READ; /* open for reading */

  /* Open the file */

#ifdef WIN32
  AVI->fdes = open(filename,O_RDONLY|O_BINARY);
#else
  AVI->fdes = open(filename,O_RDONLY);
#endif
  if(AVI->fdes < 0)
    {
      AVI_errno = AVI_ERR_OPEN;
      free(AVI);
      return 0;
    }

  avi_parse_input_file(AVI, getIndex);

  AVI->aptr=0; //reset

  return AVI;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %rdi
movl $0x488, %esi            # imm = 0x488
callq 0x4435b0
testq %rax, %rax
je 0x402f9d
movq %rax, %rbx
movq $0x1, 0x8(%rax)
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x47ed70
cltq
movq %rax, (%rbx)
testl %eax, %eax
js 0x402faa
movq %rbx, %rdi
movl %ebp, %esi
callq 0x402fc7
andl $0x0, 0x43c(%rbx)
jmp 0x402fbf
movq $0x8, 0x115588(%rip) # 0x518530
jmp 0x402fbd
movq $0x2, 0x11557b(%rip) # 0x518530
movq %rbx, %rdi
callq 0x4424a0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_open_fd
avi_t *AVI_open_fd(int fd, int getIndex)
{
  avi_t *AVI=NULL;

  /* Create avi_t structure */

  AVI = (avi_t *) malloc(sizeof(avi_t));
  if(AVI==NULL)
    {
      AVI_errno = AVI_ERR_NO_MEM;
      return 0;
    }
  memset((void *)AVI,0,sizeof(avi_t));

  AVI->mode = AVI_MODE_READ; /* open for reading */

  // file alread open
  AVI->fdes = fd;

  avi_parse_input_file(AVI, getIndex);

  AVI->aptr=0; //reset

  return AVI;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rdi
movl $0x488, %esi            # imm = 0x488
callq 0x4435b0
movq %rax, %r14
testq %rax, %rax
je 0x403c7e
movq $0x1, 0x8(%r14)
movslq %ebp, %rax
movq %rax, (%r14)
movq %r14, %rdi
movl %ebx, %esi
callq 0x402fc7
andl $0x0, 0x43c(%r14)
jmp 0x403c89
movq $0x8, 0x1148a7(%rip) # 0x518530
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_read
static size_t avi_read(int fd, char *buf, size_t len)
{
   size_t n = 0;
   size_t r = 0;

   while (r < len) {
      n = read (fd, buf + r, len - r);

      if ((ssize_t)n <= 0)
	  return r;
      r += n;
   }

   return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %ecx, %ecx
movq %rcx, %r15
movq %rbx, %rdx
subq %rcx, %rdx
jbe 0x403cc1
leaq (%r14,%r15), %rsi
movl %ebp, %edi
callq 0x47eea0
leaq (%rax,%r15), %rcx
testq %rax, %rax
jg 0x403ca2
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_frame_size
long AVI_frame_size(avi_t *AVI, long frame)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(frame < 0 || frame >= AVI->video_frames) return 0;
   return(AVI->video_index[frame].len);
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x403dd0
movq 0x410(%rdi), %rax
testq %rax, %rax
je 0x403de0
testq %rsi, %rsi
js 0x403ddd
cmpq %rsi, 0x40(%rdi)
jle 0x403ddd
imulq $0x18, %rsi, %rcx
movq 0x10(%rax,%rcx), %rax
retq
movq $0x7, 0x114755(%rip) # 0x518530
jmp 0x403deb
xorl %eax, %eax
retq
movq $0xd, 0x114745(%rip) # 0x518530
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_audio_size
long AVI_audio_size(avi_t *AVI, long frame)
{
  if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
  if(!AVI->track[AVI->aptr].audio_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

  if(frame < 0 || frame >= AVI->track[AVI->aptr].audio_chunks) return 0;
  return(AVI->track[AVI->aptr].audio_index[frame].len);
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x403e2a
movslq 0x43c(%rdi), %rax
imulq $0x70, %rax, %rcx
movq 0xc8(%rdi,%rcx), %rax
testq %rax, %rax
je 0x403e3a
testq %rsi, %rsi
js 0x403e37
addq %rdi, %rcx
addq $0x60, %rcx
cmpq %rsi, 0x38(%rcx)
jle 0x403e37
imulq $0x18, %rsi, %rcx
movq 0x8(%rax,%rcx), %rax
retq
movq $0x7, 0x1146fb(%rip) # 0x518530
jmp 0x403e45
xorl %eax, %eax
retq
movq $0xd, 0x1146eb(%rip) # 0x518530
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_get_video_position
long AVI_get_video_position(avi_t *AVI, long frame)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(frame < 0 || frame >= AVI->video_frames) return 0;
   return(AVI->video_index[frame].pos);
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x403e71
movq 0x410(%rdi), %rax
testq %rax, %rax
je 0x403e81
testq %rsi, %rsi
js 0x403e7e
cmpq %rsi, 0x40(%rdi)
jle 0x403e7e
imulq $0x18, %rsi, %rcx
movq 0x8(%rax,%rcx), %rax
retq
movq $0x7, 0x1146b4(%rip) # 0x518530
jmp 0x403e8c
xorl %eax, %eax
retq
movq $0xd, 0x1146a4(%rip) # 0x518530
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_seek_start
int AVI_seek_start(avi_t *AVI)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }

   lseek(AVI->fdes,AVI->movi_start,SEEK_SET);
   AVI->video_pos = 0;
   return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x403eb6
movq %rdi, %rbx
movl (%rdi), %edi
movq 0x430(%rbx), %rsi
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x47efe0
andq $0x0, 0x50(%rbx)
jmp 0x403ec4
movq $0x7, 0x11466f(%rip) # 0x518530
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_set_video_position
int AVI_set_video_position(avi_t *AVI, long frame)
{
   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if (frame < 0 ) frame = 0;
   AVI->video_pos = frame;
   return 0;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x403eec
cmpq $0x0, 0x410(%rdi)
je 0x403ef9
xorl %eax, %eax
testq %rsi, %rsi
cmovleq %rax, %rsi
movq %rsi, 0x50(%rdi)
retq
movq $0x7, 0x114639(%rip) # 0x518530
jmp 0x403f04
movq $0xd, 0x11462c(%rip) # 0x518530
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_read_frame
long AVI_read_frame(avi_t *AVI, char *vidbuf, int *keyframe)
{
   long n;

   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->video_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(AVI->video_pos < 0 || AVI->video_pos >= AVI->video_frames) return -1;
   n = AVI->video_index[AVI->video_pos].len;

   *keyframe = (AVI->video_index[AVI->video_pos].key==0x10) ? 1:0;

   lseek(AVI->fdes, AVI->video_index[AVI->video_pos].pos, SEEK_SET);

   if (avi_read(AVI->fdes,vidbuf,n) != n)
   {
      AVI_errno = AVI_ERR_READ;
      return -1;
   }

   AVI->video_pos++;

   return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x403fa8
movq %rdi, %r14
movq 0x410(%rdi), %rax
testq %rax, %rax
je 0x403fb5
movq 0x50(%r14), %rcx
pushq $-0x1
popq %rbx
testq %rcx, %rcx
js 0x403fc3
cmpq 0x40(%r14), %rcx
jge 0x403fc3
movq %rsi, %r15
imulq $0x18, %rcx, %rcx
movq 0x10(%rax,%rcx), %r12
xorl %esi, %esi
cmpq $0x10, (%rax,%rcx)
sete %sil
movl %esi, (%rdx)
movl (%r14), %edi
movq 0x8(%rax,%rcx), %rsi
xorl %edx, %edx
callq 0x47efe0
movl (%r14), %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x403c91
cmpq %r12, %rax
jne 0x403fd2
incq 0x50(%r14)
movq %r12, %rbx
jmp 0x403fc3
movq $0x7, 0x11457d(%rip) # 0x518530
jmp 0x403fc0
movq $0xd, 0x114570(%rip) # 0x518530
pushq $-0x1
popq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $0x3, 0x114553(%rip) # 0x518530
jmp 0x403fc3
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_set_audio_position
int AVI_set_audio_position(avi_t *AVI, long byte)
{
   long n0, n1, n;

   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->track[AVI->aptr].audio_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if(byte < 0) byte = 0;

   /* Binary search in the audio chunks */

   n0 = 0;
   n1 = AVI->track[AVI->aptr].audio_chunks;

   while(n0<n1-1)
   {
      n = (n0+n1)/2;
      if(AVI->track[AVI->aptr].audio_index[n].tot>byte)
         n1 = n;
      else
         n0 = n;
   }

   AVI->track[AVI->aptr].audio_posc = n0;
   AVI->track[AVI->aptr].audio_posb = byte - AVI->track[AVI->aptr].audio_index[n0].tot;

   return 0;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x40405e
movslq 0x43c(%rdi), %rax
imulq $0x70, %rax, %r8
movq 0xc8(%rdi,%r8), %rcx
testq %rcx, %rcx
je 0x40406b
pushq %rbx
leaq (%rdi,%r8), %r9
addq $0x60, %r9
addq $0x60, %rdi
xorl %r10d, %r10d
testq %rsi, %rsi
cmovleq %r10, %rsi
movq 0x38(%r9), %r11
movabsq $0x2, %rbx
leaq -0x1(%r11), %rax
cmpq %rax, %r10
jge 0x404048
leaq (%r11,%r10), %rax
cqto
idivq %rbx
imulq $0x18, %rax, %rdx
cmpq %rsi, 0x10(%rcx,%rdx)
cmovleq %rax, %r10
cmovgq %rax, %r11
jmp 0x404023
movq %r10, 0x48(%rdi,%r8)
imulq $0x18, %r10, %rax
subq 0x10(%rcx,%rax), %rsi
movq %rsi, 0x50(%r9)
xorl %eax, %eax
popq %rbx
retq
movq $0x7, 0x1144c7(%rip) # 0x518530
jmp 0x404076
movq $0xd, 0x1144ba(%rip) # 0x518530
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_read_audio
long AVI_read_audio(avi_t *AVI, char *audbuf, long bytes)
{
   long nr, pos, left, todo;

   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->track[AVI->aptr].audio_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   nr = 0; /* total number of bytes read */

   while(bytes>0)
   {
      left = AVI->track[AVI->aptr].audio_index[AVI->track[AVI->aptr].audio_posc].len - AVI->track[AVI->aptr].audio_posb;
      if(left==0)
      {
         if(AVI->track[AVI->aptr].audio_posc>=AVI->track[AVI->aptr].audio_chunks-1) return nr;
         AVI->track[AVI->aptr].audio_posc++;
         AVI->track[AVI->aptr].audio_posb = 0;
         continue;
      }
      if(bytes<left)
         todo = bytes;
      else
         todo = left;
      pos = AVI->track[AVI->aptr].audio_index[AVI->track[AVI->aptr].audio_posc].pos + AVI->track[AVI->aptr].audio_posb;
      lseek(AVI->fdes, pos, SEEK_SET);
      if (avi_read(AVI->fdes,audbuf+nr,todo) != todo)
      {
         AVI_errno = AVI_ERR_READ;
         return -1;
      }
      bytes -= todo;
      nr    += todo;
      AVI->track[AVI->aptr].audio_posb += todo;
   }

   return nr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x404160
movq %rdi, %r15
movslq 0x43c(%rdi), %rax
imulq $0x70, %rax, %rcx
cmpq $0x0, 0xc8(%rdi,%rcx)
je 0x404164
movq %rdx, %rbx
movq %rsi, (%rsp)
leaq 0x60(%r15), %r14
xorl %r12d, %r12d
pushq $0x3
popq %rbp
testq %rbx, %rbx
jle 0x404172
cltq
imulq $0x70, %rax, %rcx
leaq (%r14,%rcx), %rax
leaq (%r14,%rcx), %rdx
addq $0x50, %rdx
movq 0x18(%rdx), %rcx
movq -0x8(%rdx), %rdi
movq (%rdx), %rsi
imulq $0x18, %rdi, %r8
addq %r8, %rcx
addq $0x8, %rcx
movq (%rcx), %r13
subq %rsi, %r13
jne 0x404118
movq 0x38(%rax), %rsi
decq %rsi
cmpq %rsi, %rdi
jge 0x404172
incq %rdi
movq %rdi, 0x48(%rax)
andq $0x0, (%rdx)
addq $0x18, %rcx
xorl %esi, %esi
jmp 0x4040f1
cmpq %r13, %rbx
cmovlq %rbx, %r13
addq -0x8(%rcx), %rsi
movl (%r15), %edi
xorl %edx, %edx
callq 0x47efe0
movl (%r15), %edi
movq (%rsp), %rax
leaq (%rax,%r12), %rsi
movq %r13, %rdx
callq 0x403c91
cmpq %r13, %rax
jne 0x404167
subq %r13, %rbx
addq %r13, %r12
movslq 0x43c(%r15), %rax
imulq $0x70, %rax, %rcx
addq %r13, 0x50(%r14,%rcx)
jmp 0x4040c0
pushq $0x7
jmp 0x404166
pushq $0xd
popq %rbp
movq %rbp, 0x1143c2(%rip)    # 0x518530
pushq $-0x1
popq %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_read_audio_chunk
long AVI_read_audio_chunk(avi_t *AVI, char *audbuf)
{
   long pos, left;

   if(AVI->mode==AVI_MODE_WRITE) { AVI_errno = AVI_ERR_NOT_PERM; return -1; }
   if(!AVI->track[AVI->aptr].audio_index)         { AVI_errno = AVI_ERR_NO_IDX;   return -1; }

   if (AVI->track[AVI->aptr].audio_index[AVI->track[AVI->aptr].audio_posc].len == 0) return 0;
   left = AVI->track[AVI->aptr].audio_index[AVI->track[AVI->aptr].audio_posc].len - AVI->track[AVI->aptr].audio_posb;

   if (audbuf == NULL) return left;

   if(left==0) return 0;

   pos = AVI->track[AVI->aptr].audio_index[AVI->track[AVI->aptr].audio_posc].pos + AVI->track[AVI->aptr].audio_posb;
   lseek(AVI->fdes, pos, SEEK_SET);
   if (avi_read(AVI->fdes,audbuf,left) != left)
   {
      AVI_errno = AVI_ERR_READ;
      return -1;
   }
   AVI->track[AVI->aptr].audio_posc++;
   AVI->track[AVI->aptr].audio_posb = 0;

   return left;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x0, 0x8(%rdi)
je 0x404219
movq %rdi, %r14
movslq 0x43c(%rdi), %rax
imulq $0x70, %rax, %rcx
movq 0xc8(%rdi,%rcx), %rax
testq %rax, %rax
je 0x404226
leaq (%r14,%rcx), %rdx
addq $0x60, %rdx
imulq $0x18, 0x48(%rdx), %rcx
movq 0x8(%rax,%rcx), %rbx
testq %rbx, %rbx
je 0x404236
movq %rsi, %r15
movq 0x50(%rdx), %rsi
subq %rsi, %rbx
testq %r15, %r15
je 0x404238
testq %rbx, %rbx
je 0x404236
addq %rcx, %rax
addq (%rax), %rsi
movl (%r14), %edi
xorl %edx, %edx
callq 0x47efe0
movl (%r14), %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x403c91
cmpq %rbx, %rax
jne 0x404241
movslq 0x43c(%r14), %rax
addq $0x60, %r14
imulq $0x70, %rax, %rax
incq 0x48(%r14,%rax)
andq $0x0, 0x50(%r14,%rax)
jmp 0x404238
movq $0x7, 0x11430c(%rip) # 0x518530
jmp 0x404231
movq $0xd, 0x1142ff(%rip) # 0x518530
pushq $-0x1
popq %rbx
jmp 0x404238
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq $0x3, 0x1142e4(%rip) # 0x518530
jmp 0x404231
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_print_error
void AVI_print_error(char *str)
{
   int aerrno;

   aerrno = (AVI_errno>=0 && AVI_errno<num_avi_errors) ? AVI_errno : num_avi_errors-1;

   fprintf(stderr,"%s: %s\n",str,avi_errors[aerrno]);

   /* for the following errors, perror should report a more detailed reason: */

   if(AVI_errno == AVI_ERR_OPEN ||
      AVI_errno == AVI_ERR_READ ||
      AVI_errno == AVI_ERR_WRITE ||
      AVI_errno == AVI_ERR_WRITE_INDEX ||
      AVI_errno == AVI_ERR_CLOSE )
   {
      perror("REASON");
   }
}

// Assembly:
pushq %rax
movq %rdi, %rdx
movq 0x114165(%rip), %rax    # 0x518530
movl %eax, %ecx
cmpq $0xf, %rax
pushq $0xe
popq %rax
cmovbq %rcx, %rax
movq $0x516868, %rcx         # imm = 0x516868
movq (%rcx), %rdi
leaq 0x111d87(%rip), %rcx    # 0x516170
movq (%rcx,%rax,8), %rcx
leaq 0xcdf03(%rip), %rsi     # 0x4d22f7
xorl %eax, %eax
callq 0x424b10
movq 0x11412e(%rip), %rax    # 0x518530
addq $-0x2, %rax
cmpq $0x4, %rax
jbe 0x40440e
popq %rax
retq
leaq 0xcdeea(%rip), %rdi     # 0x4d22ff
popq %rax
jmp 0x424f90
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: AVI_strerror
const char *AVI_strerror()
{
   int aerrno;

   aerrno = (AVI_errno>=0 && AVI_errno<num_avi_errors) ? AVI_errno : num_avi_errors-1;

   if(AVI_errno == AVI_ERR_OPEN ||
      AVI_errno == AVI_ERR_READ ||
      AVI_errno == AVI_ERR_WRITE ||
      AVI_errno == AVI_ERR_WRITE_INDEX ||
      AVI_errno == AVI_ERR_CLOSE )
   {
      sprintf(error_string,"%s - %s",avi_errors[aerrno],strerror(errno));
      return error_string;
   }
   else
   {
      return avi_errors[aerrno];
   }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x11410a(%rip), %rcx    # 0x518530
movl %ecx, %eax
leaq -0x2(%rcx), %rdx
cmpq $0x4, %rdx
ja 0x404469
leaq 0x111d37(%rip), %rcx    # 0x516170
movq (%rcx,%rax,8), %r14
callq 0x41d100
movl (%rax), %edi
callq 0x444900
leaq 0x1140f0(%rip), %rbx    # 0x518540
leaq 0xcdeaf(%rip), %rsi     # 0x4d2306
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x424d60
jmp 0x40447f
cmpq $0xf, %rcx
pushq $0xe
popq %rcx
cmovaeq %rcx, %rax
leaq 0x111cf5(%rip), %rcx    # 0x516170
movq (%rcx,%rax,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/avilib.c
// Function: avi_add_chunk
static int avi_add_chunk(avi_t *AVI, unsigned char *tag, unsigned char *data, int length)
{
   unsigned char c[8];

   /* Copy tag and length int c, so that we need only 1 write system call
      for these two values */

   memcpy(c,tag,4);
   long2str(c+4,length);

   /* Output tag, length and data, restore previous position
      if the write fails */

   length = PAD_EVEN(length);

   if( avi_write(AVI->fdes,(char *)c,8) != 8 ||
       avi_write(AVI->fdes,(char *)data,length) != length )
   {
      lseek(AVI->fdes,AVI->pos,SEEK_SET);
      AVI_errno = AVI_ERR_WRITE;
      return -1;
   }

   /* Update file position */

   AVI->pos += 8 + length;

   //fprintf(stderr, "pos=%lu %s\n", AVI->pos, tag);

   return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl (%rsi), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movb %bl, 0x4(%rsi)
movb %bh, 0xd(%rsp)
movl %ecx, %eax
shrl $0x10, %eax
movb %al, 0x6(%rsi)
movl %ecx, %eax
shrl $0x18, %eax
movb %al, 0x7(%rsi)
movl (%rdi), %edi
pushq $0x8
popq %rdx
callq 0x4019c5
cmpq $0x8, %rax
jne 0x404505
incl %ebx
andl $-0x2, %ebx
movl (%r15), %edi
movslq %ebx, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4019c5
cmpq %rbx, %rax
jne 0x404505
movq 0x3e0(%r15), %rax
addq %rbx, %rax
addq $0x8, %rax
movq %rax, 0x3e0(%r15)
xorl %eax, %eax
jmp 0x404524
movl (%r15), %edi
movq 0x3e0(%r15), %rsi
xorl %edx, %edx
callq 0x47efe0
movq $0x4, 0x11400f(%rip) # 0x518530
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/base64.c
// Function: base64_encode
void base64_encode(unsigned char const* bytes_to_encode,unsigned int in_len, char *out) {
  //todo: test

  static const char * base64_chars =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789+/";

  int outInd=0;
  int i = 0;
  int j = 0;
  unsigned char char_array_3[3];
  unsigned char char_array_4[4];

  while(in_len--) {
    char_array_3[i++] = *(bytes_to_encode++);

    if(i == 3) {
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
      char_array_4[3] = char_array_3[2] & 0x3f;

      for(i = 0; (i <4); i++) {
        out[outInd++]=base64_chars[char_array_4[i]];
      }

      i = 0;
    }
  }

  if(i) {
    for(j = i; j < 3; j++) {
      char_array_3[j] = '\0';
    }

    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
    char_array_4[3] = char_array_3[2] & 0x3f;

    for(j = 0; (j < i + 1); j++) {
      out[outInd++]=base64_chars[char_array_4[j]];
    }

    while((i++ < 3)) {
      out[outInd++]='=';
    }
  }
}

// Assembly:
pushq %rbx
xorl %r9d, %r9d
leaq 0xcddda(%rip), %rax     # 0x4d2315
movl %esi, %esi
xorl %ecx, %ecx
movslq %r9d, %r8
cmpl %ecx, %esi
je 0x4045d5
movb (%rdi,%rcx), %r10b
movb %r10b, -0x7(%rsp,%rcx)
incq %rcx
cmpl $0x3, %ecx
jne 0x40453f
movb -0x7(%rsp), %r10b
movb -0x6(%rsp), %r11b
movl %r10d, %ebx
shrb $0x2, %bl
movb %bl, -0x4(%rsp)
movl %r11d, %ebx
shrb $0x4, %bl
shlb $0x4, %r10b
orb %bl, %r10b
andb $0x3f, %r10b
movb %r10b, -0x3(%rsp)
movb -0x5(%rsp), %r10b
movl %r10d, %ebx
shrb $0x6, %bl
shlb $0x2, %r11b
orb %bl, %r11b
andb $0x3f, %r11b
movb %r11b, -0x2(%rsp)
andb $0x3f, %r10b
movb %r10b, -0x1(%rsp)
subq %rcx, %rsi
addq %rcx, %rdi
addq %rdx, %r8
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x4045cd
movzbl -0x4(%rsp,%rcx), %r10d
movb (%r10,%rax), %r10b
movb %r10b, (%r8,%rcx)
incq %rcx
jmp 0x4045b4
addl %ecx, %r9d
jmp 0x40453b
testl %ecx, %ecx
je 0x40466f
movq %rcx, %rsi
cmpl $0x2, %esi
jg 0x4045ef
movb $0x0, -0x7(%rsp,%rsi)
incq %rsi
jmp 0x4045e0
movb -0x7(%rsp), %sil
movb -0x6(%rsp), %dil
movl %esi, %r9d
shrb $0x2, %r9b
movb %r9b, -0x4(%rsp)
movl %edi, %r9d
shrb $0x4, %r9b
shlb $0x4, %sil
orb %r9b, %sil
andb $0x3f, %sil
movb %sil, -0x3(%rsp)
movb -0x5(%rsp), %sil
movl %esi, %r9d
shrb $0x6, %r9b
shlb $0x2, %dil
orb %r9b, %dil
andb $0x3f, %dil
movb %dil, -0x2(%rsp)
andb $0x3f, %sil
movb %sil, -0x1(%rsp)
addq %r8, %rdx
xorl %esi, %esi
cmpq %rcx, %rsi
ja 0x40465d
movzbl -0x4(%rsp,%rsi), %edi
movb (%rdi,%rax), %dil
movb %dil, (%rdx,%rsi)
incq %rsi
jmp 0x404646
addq %rsi, %rdx
cmpl $0x2, %ecx
ja 0x40466f
incl %ecx
movb $0x3d, (%rdx)
incq %rdx
jmp 0x404660
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/jo_jpeg.c
// Function: jo_writeBits
static void jo_writeBits(FILE *fp,
                         int *bitBuf, int *bitCnt,
                         const unsigned short *bs) {
  (*bitCnt) += bs[1];
  (*bitBuf) |= bs[0] << (24 - (*bitCnt));
  while((*bitCnt) >= 8) {
    unsigned char c = ((*bitBuf) >> 16) & 255;
    putc(c, fp);
    if(c == 255) {
      putc(0, fp);
    }
    (*bitBuf) <<= 8;
    (*bitCnt) -= 8;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzwl 0x2(%rcx), %eax
addl (%rdx), %eax
movl %eax, (%rdx)
movzwl (%rcx), %edx
movb $0x18, %cl
subb %al, %cl
shll %cl, %edx
orl %edx, (%rsi)
movl (%rbx), %eax
cmpl $0x8, %eax
jl 0x405293
movzbl 0x2(%r14), %ebp
movl %ebp, %edi
movq %r15, %rsi
callq 0x42fea0
cmpl $0xff, %ebp
jne 0x405286
xorl %edi, %edi
movq %r15, %rsi
callq 0x42fea0
shll $0x8, (%r14)
movl (%rbx), %eax
addl $-0x8, %eax
movl %eax, (%rbx)
jmp 0x405260
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/jo_jpeg.c
// Function: jo_DCT
static void jo_DCT(float *d0, float *d1, float *d2,
                   float *d3, float *d4, float *d5,
                   float *d6, float *d7) {

  float tmp0 = (*d0) + (*d7);
  float tmp7 = (*d0) - (*d7);
  float tmp1 = (*d1) + (*d6);
  float tmp6 = (*d1) - (*d6);
  float tmp2 = (*d2) + (*d5);
  float tmp5 = (*d2) - (*d5);
  float tmp3 = (*d3) + (*d4);
  float tmp4 = (*d3) - (*d4);

  // Even part
  float tmp10 = tmp0 + tmp3;	// phase 2
  float tmp13 = tmp0 - tmp3;
  float tmp11 = tmp1 + tmp2;
  float tmp12 = tmp1 - tmp2;

  (*d0) = tmp10 + tmp11; 		// phase 3
  (*d4) = tmp10 - tmp11;

  float z1 = (tmp12 + tmp13) * 0.707106781f; // c4
  (*d2) = tmp13 + z1; 		// phase 5
  (*d6) = tmp13 - z1;

  // Odd part
  tmp10 = tmp4 + tmp5; 		// phase 2
  tmp11 = tmp5 + tmp6;
  tmp12 = tmp6 + tmp7;

  // The rotator is modified from fig 4-8 to avoid extra negations.
  float z5 = (tmp10 - tmp12) * 0.382683433f; // c6
  float z2 = tmp10 * 0.541196100f + z5; // c2-c6
  float z4 = tmp12 * 1.306562965f + z5; // c2+c6
  float z3 = tmp11 * 0.707106781f; // c4

  float z11 = tmp7 + z3;		// phase 5
  float z13 = tmp7 - z3;

  (*d5) = z13 + z2;			// phase 6
  (*d3) = z13 - z2;
  (*d1) = z11 + z4;
  (*d7) = z11 - z4;
}

// Assembly:
movq 0x8(%rsp), %r10
movq 0x10(%rsp), %rax
movss (%rdi), %xmm0
movss (%rax), %xmm1
movaps %xmm0, %xmm4
addss %xmm1, %xmm4
subss %xmm1, %xmm0
movss (%rsi), %xmm1
movss (%r10), %xmm2
movaps %xmm1, %xmm5
addss %xmm2, %xmm5
subss %xmm2, %xmm1
movss (%rdx), %xmm2
movss (%r9), %xmm3
movaps %xmm2, %xmm6
addss %xmm3, %xmm6
subss %xmm3, %xmm2
movss (%rcx), %xmm3
movss (%r8), %xmm7
movaps %xmm3, %xmm8
addss %xmm7, %xmm8
subss %xmm7, %xmm3
movaps %xmm4, %xmm7
addss %xmm8, %xmm7
subss %xmm8, %xmm4
movaps %xmm5, %xmm8
addss %xmm6, %xmm8
subss %xmm6, %xmm5
movaps %xmm8, %xmm6
addss %xmm7, %xmm6
movss %xmm6, (%rdi)
subss %xmm8, %xmm7
movss %xmm7, (%r8)
addss %xmm4, %xmm5
movss 0xcd15b(%rip), %xmm6    # 0x4d2490
mulss %xmm6, %xmm5
movaps %xmm4, %xmm7
addss %xmm5, %xmm7
movss %xmm7, (%rdx)
subss %xmm5, %xmm4
movss %xmm4, (%r10)
addss %xmm2, %xmm3
addss %xmm1, %xmm2
addss %xmm0, %xmm1
movaps %xmm3, %xmm4
subss %xmm1, %xmm4
mulss 0xcd12c(%rip), %xmm4    # 0x4d2494
mulss 0xcd128(%rip), %xmm3    # 0x4d2498
mulss 0xcd124(%rip), %xmm1    # 0x4d249c
addss %xmm4, %xmm3
addss %xmm4, %xmm1
mulss %xmm6, %xmm2
movaps %xmm0, %xmm4
addss %xmm2, %xmm4
subss %xmm2, %xmm0
movaps %xmm0, %xmm2
addss %xmm3, %xmm2
movss %xmm2, (%r9)
subss %xmm3, %xmm0
movss %xmm0, (%rcx)
movaps %xmm4, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rsi)
subss %xmm1, %xmm4
movss %xmm4, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/jo_jpeg.c
// Function: jo_calcBits
static void jo_calcBits(int val, unsigned short bits[2]) {
  int tmp1 = val < 0 ? -val : val;
  val = val < 0 ? val-1 : val;
  bits[1] = 1;
  while(tmp1 >>= 1) {
    ++bits[1];
  }
  bits[0] = val & ((1<<bits[1])-1);
}

// Assembly:
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
pushq $0x1
popq %rcx
cmpl $0x2, %eax
jb 0x4053cc
shrl %eax
incl %ecx
jmp 0x4053c1
movw %cx, 0x2(%rsi)
movl %edi, %eax
sarl $0x1f, %eax
pushq $-0x1
popq %rdx
shll %cl, %edx
addl %edi, %eax
notl %edx
andl %eax, %edx
movw %dx, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/kdtree.c
// Function: calcSaCost
bool calcSaCost(int axis,float edget,int nAbove,int nBelow,
                float invTotalSa,const float *minBound,const float *maxBound,
                float emptyBonus,float traversalCost,float isectCost,
                float *cost) {

  float belowSa,aboveSa,pBelow,pAbove,eb,diag[3];
  int otherAxis0,otherAxis1;

  if(!(edget > minBound[axis] && edget < maxBound[axis])) {
    return false;
  }

  diag[0]=maxBound[0]-minBound[0];
  diag[1]=maxBound[1]-minBound[1];
  diag[2]=maxBound[2]-minBound[2];

  otherAxis0=(axis+1)%3;
  otherAxis1=(axis+2)%3;

  belowSa=2.0f*(diag[otherAxis0]*diag[otherAxis1]+
                (edget-minBound[axis])*
                (diag[otherAxis0]+diag[otherAxis1]));
  aboveSa=2.0f*(diag[otherAxis0]*diag[otherAxis1]+
                (maxBound[axis]-edget)*
                (diag[otherAxis0]+diag[otherAxis1]));

  pBelow=belowSa*invTotalSa;
  pAbove=aboveSa*invTotalSa;

  eb=(nAbove==0 || nBelow==0)?emptyBonus:0.0f;
  *cost=traversalCost+isectCost*(1.0f-eb)*
    (pBelow*(float)nBelow+pAbove*(float)nAbove);

  return true;
}

// Assembly:
movslq %edi, %rax
movss (%rcx,%rax,4), %xmm5
ucomiss %xmm5, %xmm0
jbe 0x405574
movss (%r8,%rax,4), %xmm6
ucomiss %xmm0, %xmm6
jbe 0x405574
movl %edx, %r10d
movsd (%r8), %xmm7
movsd (%rcx), %xmm8
subps %xmm8, %xmm7
movlps %xmm7, -0x10(%rsp)
movss 0x8(%r8), %xmm7
subss 0x8(%rcx), %xmm7
movss %xmm7, -0x8(%rsp)
leal 0x1(%rdi), %eax
movl $0x3, %r8d
cltd
idivl %r8d
movl %edx, %ecx
addl $0x2, %edi
movl %edi, %eax
cltd
idivl %r8d
movslq %ecx, %rax
movss -0x10(%rsp,%rax,4), %xmm7
movslq %edx, %rax
movss -0x10(%rsp,%rax,4), %xmm8
subss %xmm0, %xmm6
subss %xmm5, %xmm0
movaps %xmm7, %xmm5
addss %xmm8, %xmm5
mulss %xmm5, %xmm0
mulss %xmm8, %xmm7
addss %xmm7, %xmm0
addss %xmm0, %xmm0
mulss %xmm6, %xmm5
addss %xmm7, %xmm5
addss %xmm5, %xmm5
movss 0xccf36(%rip), %xmm7    # 0x4d2460
movaps %xmm7, %xmm6
subss %xmm2, %xmm6
movaps %xmm6, %xmm2
testl %r10d, %r10d
je 0x40553c
movaps %xmm7, %xmm2
mulss %xmm1, %xmm0
mulss %xmm1, %xmm5
testl %esi, %esi
je 0x40554b
movaps %xmm2, %xmm6
cvtsi2ss %r10d, %xmm1
cvtsi2ss %esi, %xmm2
mulss %xmm4, %xmm6
mulss %xmm1, %xmm0
mulss %xmm2, %xmm5
addss %xmm0, %xmm5
mulss %xmm6, %xmm5
addss %xmm3, %xmm5
movss %xmm5, (%r9)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/kdtree.c
// Function: PowInt
int PowInt(int base, int exp) {
  int result = 1;

  while (exp) {
    if (exp & 1) {
      result *= base;
    }

    exp >>= 1;
    base *= base;
  }

  return result;
}

// Assembly:
pushq $0x1
popq %rcx
movl %ecx, %eax
testl %esi, %esi
je 0x4059eb
testb $0x1, %sil
movl %edi, %edx
cmovel %ecx, %edx
imull %edx, %eax
sarl %esi
imull %edi, %edi
jmp 0x4059d4
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: InvSqrt
float InvSqrt(float x){
    float xhalf = 0.5f*x;
    int i = *(int*)&x;
    i = 0x5f3759df - (i>>1);
    x = *(float*)&i;
    x = x*(1.5f - xhalf*x*x);
    return x;
}

// Assembly:
movd %xmm0, %eax
sarl %eax
movl $0x5f3759df, %ecx       # imm = 0x5F3759DF
subl %eax, %ecx
movd %ecx, %xmm1
mulss 0xcb5e3(%rip), %xmm0    # 0x4d2488
mulss %xmm1, %xmm0
mulss %xmm1, %xmm0
addss 0xccd7b(%rip), %xmm0    # 0x4d3c30
mulss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: vec3_cross
void vec3_cross(float *out,const float *a,const float *b) {
  float tmp[3]={a[1]*b[2]-a[2]*b[1],
                a[2]*b[0]-a[0]*b[2],
                a[0]*b[1]-a[1]*b[0]};


  memcpy(out,tmp,sizeof(tmp));
}

// Assembly:
movss (%rdx), %xmm0
movss (%rsi), %xmm1
movsd 0x4(%rsi), %xmm2
movsd 0x4(%rdx), %xmm3
movaps %xmm1, %xmm4
shufps $0xd4, %xmm2, %xmm4     # xmm4 = xmm4[0,1],xmm2[1,3]
shufps $0x52, %xmm2, %xmm4     # xmm4 = xmm4[2,0],xmm2[1,1]
mulps %xmm3, %xmm4
movaps %xmm0, %xmm5
shufps $0xd4, %xmm3, %xmm5     # xmm5 = xmm5[0,1],xmm3[1,3]
shufps $0x52, %xmm3, %xmm5     # xmm5 = xmm5[2,0],xmm3[1,1]
mulps %xmm2, %xmm5
subps %xmm4, %xmm5
mulss %xmm2, %xmm0
mulss %xmm3, %xmm1
subss %xmm0, %xmm1
movlps %xmm5, (%rdi)
movss %xmm1, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: vec3_normal
void vec3_normal(float *out,const float *v) {
  float l=1.0f/vec3_length(v);
  // float l= InvSqrt(vec3_dot(v,v));
  out[0]=v[0]*l;
  out[1]=v[1]*l;
  out[2]=v[2]*l;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x406f25
movss 0xcb504(%rip), %xmm1    # 0x4d2460
divss %xmm0, %xmm1
movss (%rbx), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%r14)
movss 0x4(%rbx), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%r14)
mulss 0x8(%rbx), %xmm1
movss %xmm1, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_transpose
void mat4_transpose(float *out,float *m) {
  int i,j;
  for(i=0;i<4;i++){
    for(j=i+1;j<4;j++){
      float a = m[i*4+j];
      out[i*4+j] = m[j*4+i];
      out[j*4+i] = a;
    }
  }
}

// Assembly:
pushq $0x3
popq %rax
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x407085
xorl %edx, %edx
movq %rax, %r8
subq $0x1, %r8
jb 0x407075
movss 0x4(%rsi,%rdx), %xmm0
movss 0x10(%rsi,%rdx,4), %xmm1
movss %xmm1, 0x4(%rdi,%rdx)
movss %xmm0, 0x10(%rdi,%rdx,4)
addq $0x4, %rdx
jmp 0x407051
incq %rcx
decq %rax
addq $0x14, %rdi
addq $0x14, %rsi
jmp 0x407046
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_mul
void mat4_mul(float *out,const float *a,
                   const float *b) {
  int i,j,k;
  float tmp[16];

  for(i=0;i<4;i++) {
    for(j=0;j<4;j++){
      float x=0.0f;

      for(k=0;k<4;k++){
        x+=a[i*4+k]*b[k*4+j];
      }

      tmp[i*4+j]=x;
    }
  }

  memcpy(out,tmp,sizeof(tmp));
}

// Assembly:
xorl %eax, %eax
cmpq $0x4, %rax
je 0x4070e3
leaq (,%rax,4), %rcx
movq %rdx, %r8
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x4070da
xorps %xmm0, %xmm0
xorl %r10d, %r10d
cmpq $0x10, %r10
je 0x4070c4
movss (%rsi,%r10), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
jmp 0x4070a8
movq %r9, %r10
orq %rcx, %r10
movss %xmm0, -0x48(%rsp,%r10,4)
incq %r9
addq $0x4, %r8
jmp 0x40709c
incq %rax
addq $0x10, %rsi
jmp 0x407088
movaps -0x48(%rsp), %xmm0
movaps -0x38(%rsp), %xmm1
movaps -0x28(%rsp), %xmm2
movaps -0x18(%rsp), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_mulVector
void mat4_mulVector(float *out,
                         const float *m,
                         const float *v) {
  int i,j;
  float tmp[4];

  for(i=0;i<4;i++) {
    tmp[i]=0.0f;

    for(j=0;j<4;j++){
      tmp[i]+=m[i*4+j]*v[j];
    }
  }

  memcpy(out,tmp,sizeof(tmp));
}

// Assembly:
xorl %eax, %eax
cmpq $0x4, %rax
je 0x40713c
xorps %xmm0, %xmm0
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x40712d
movss (%rsi,%rcx,4), %xmm1
mulss (%rdx,%rcx,4), %xmm1
addss %xmm1, %xmm0
incq %rcx
jmp 0x407114
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
addq $0x10, %rsi
jmp 0x407109
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_inverse
void mat4_inverse(float *out,const float *m) {
  int K,q,L;
  float m2[16],tmp[16];
  mat4_identity(tmp);

  memcpy(m2,m,sizeof(m2));

  for(K=0;K<4;++K) {
    float factor = m2[K*4+K];

    for(q=0;q<4;q++) {
      m2[K*4+q] /= factor;
      tmp[K*4+q] /= factor;
    }

    for(L=0;L<4;++L){
      if(K==L) {
        continue;
      }

      float coefficient = m2[L*4+K];

      for(q=0;q<4;q++) {
        m2[L*4+q] -= coefficient*m2[K*4+q];
        tmp[L*4+q] -= coefficient*tmp[K*4+q];
      }
    }
  }

  memcpy(out,tmp,sizeof(tmp));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x40700a
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups 0x30(%r15), %xmm3
leaq 0x40(%rsp), %rax
movaps %xmm3, 0x30(%rax)
movaps %xmm2, 0x20(%rax)
movaps %xmm1, 0x10(%rax)
movaps %xmm0, (%rax)
xorl %ecx, %ecx
movaps 0xccabe(%rip), %xmm0    # 0x4d3c50
movq %rax, %rdx
movq %r14, %rsi
cmpq $0x4, %rcx
je 0x407255
imulq $0x14, %rcx, %rdi
movss 0x40(%rsp,%rdi), %xmm1
xorl %edi, %edi
cmpq $0x4, %rdi
je 0x4071d5
movss (%rdx,%rdi,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%rdx,%rdi,4)
movss (%rsi,%rdi,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%rsi,%rdi,4)
incq %rdi
jmp 0x4071ae
movq %rax, %rdi
movq %r14, %r8
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x407245
cmpq %r9, %rcx
jne 0x4071f6
incq %r9
addq $0x10, %r8
addq $0x10, %rdi
jmp 0x4071de
movq %r9, %r10
shlq $0x4, %r10
leaq (%r10,%rcx,4), %r10
movss 0x40(%rsp,%r10), %xmm1
xorps %xmm0, %xmm1
xorl %r10d, %r10d
cmpq $0x4, %r10
je 0x4071e9
movss (%rdx,%r10,4), %xmm2
mulss %xmm1, %xmm2
addss (%rdi,%r10,4), %xmm2
movss %xmm2, (%rdi,%r10,4)
movss (%rsi,%r10,4), %xmm2
mulss %xmm1, %xmm2
addss (%r8,%r10,4), %xmm2
movss %xmm2, (%r8,%r10,4)
incq %r10
jmp 0x40720e
incq %rcx
addq $0x10, %rsi
addq $0x10, %rdx
jmp 0x407198
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_normal
void mat4_normal(float *out,const float *m) {
  float m2[16];
  mat4_inverse(m2,m);
  mat4_transpose(m2,m2);

  memcpy(out,m2,sizeof(m2));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x407145
movq %r14, %rdi
movq %r14, %rsi
callq 0x407041
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps 0x20(%r14), %xmm2
movaps 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_translate
void mat4_translate(float *out,const float *v, bool mul) {
  int i;
  float mat[16];
  mat4_identity(mat);

  for(i=0;i<3;i++) {
    mat[3+i*4]=v[i];
  }

  //
  if(mul) {
    mat4_mul(out,out,mat);
  } else {
    memcpy(out,mat,sizeof(mat));
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x40700a
pushq $0x3
popq %rax
cmpq $0xf, %rax
je 0x40732a
movss -0x3(%r14,%rax), %xmm0
movss %xmm0, (%rsp,%rax,4)
addq $0x4, %rax
jmp 0x407312
testb %bpl, %bpl
je 0x40733f
movq %rsp, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407086
jmp 0x407361
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_scale
void mat4_scale(float *out,const float *v,bool mul) {
  int i;
  float mat[16];
  mat4_identity(mat);

  for(i=0;i<3;i++) {
    mat[i*5]=v[i];
  }

  //
  if(mul) {
    mat4_mul(out,out,mat);
  } else {
    memcpy(out,mat,sizeof(mat));
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x40700a
xorl %eax, %eax
cmpq $0xf, %rax
je 0x40739e
movss (%r14), %xmm0
movss %xmm0, (%rsp,%rax,4)
addq $0x5, %rax
addq $0x4, %r14
jmp 0x407384
testb %bpl, %bpl
je 0x4073b3
movq %rsp, %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407086
jmp 0x4073d5
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_rotateX
void mat4_rotateX(float *out,float x, bool mul) {
  float mat[16];
  mat4_identity(mat);

  float c=cosf(x);
  float s=sinf(x);

  mat[5]=c;
  mat[6]=-s;
  mat[9]=s;
  mat[10]=c;

  //
  if(mul) {
    mat4_mul(out,out,mat);
  } else {
    memcpy(out,mat,sizeof(mat));
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x40700a
movss 0x8(%rsp), %xmm0
callq 0x401080
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x401120
movss 0xc(%rsp), %xmm2
movss %xmm2, 0x14(%r14)
movaps 0xcc823(%rip), %xmm1    # 0x4d3c50
xorps %xmm0, %xmm1
movss %xmm1, 0x18(%r14)
movss %xmm0, 0x24(%r14)
movss %xmm2, 0x28(%r14)
testl %ebp, %ebp
je 0x407458
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407086
jmp 0x40747b
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_rotateY
void mat4_rotateY(float *out,float y,bool mul) {
  float mat[16];
  mat4_identity(mat);

  float c=cosf(y);
  float s=sinf(y);

  mat[0]=c;
  mat[2]=s;
  mat[8]=-s;
  mat[10]=c;

  //
  if(mul) {
    mat4_mul(out,out,mat);
  } else {
    memcpy(out,mat,sizeof(mat));
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x40700a
movss 0x8(%rsp), %xmm0
callq 0x401080
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x401120
movss 0xc(%rsp), %xmm1
movss %xmm1, (%r14)
movss %xmm0, 0x8(%r14)
xorps 0xcc778(%rip), %xmm0    # 0x4d3c50
movss %xmm0, 0x20(%r14)
movss %xmm1, 0x28(%r14)
testl %ebp, %ebp
je 0x4074fa
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407086
jmp 0x40751d
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_rotateZ
void mat4_rotateZ(float *out,float z,bool mul) {
  float mat[16];
  mat4_identity(mat);

  float c=cosf(z);
  float s=sinf(z);

  mat[0]=c;
  mat[1]=-s;
  mat[4]=s;
  mat[5]=c;

  //
  if(mul) {
    mat4_mul(out,out,mat);
  } else {
    memcpy(out,mat,sizeof(mat));
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebp
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x40700a
movss 0x8(%rsp), %xmm0
callq 0x401080
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x401120
movss 0xc(%rsp), %xmm2
movss %xmm2, (%r14)
movaps 0xcc6dc(%rip), %xmm1    # 0x4d3c50
xorps %xmm0, %xmm1
movss %xmm1, 0x4(%r14)
movss %xmm0, 0x10(%r14)
movss %xmm2, 0x14(%r14)
testl %ebp, %ebp
je 0x40759f
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407086
jmp 0x4075c2
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps 0x30(%rsp), %xmm2
movaps 0x40(%rsp), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: mat3_mulVector
void mat3_mulVector(float *out,const float *m,const float *v) {
  int i,j;
  float tmp[3];

  for(i=0;i<3;i++) {
    tmp[i]=0.0f;

    for(j=0;j<3;j++){
      tmp[i]+=m[i*3+j]*v[j];
    }
  }

  memcpy(out,tmp,sizeof(tmp));
}

// Assembly:
xorl %eax, %eax
cmpq $0x3, %rax
je 0x407a05
xorps %xmm0, %xmm0
xorl %ecx, %ecx
cmpq $0x3, %rcx
je 0x4079f6
movss (%rsi,%rcx,4), %xmm1
mulss (%rdx,%rcx,4), %xmm1
addss %xmm1, %xmm0
incq %rcx
jmp 0x4079dd
movss %xmm0, -0xc(%rsp,%rax,4)
incq %rax
addq $0xc, %rsi
jmp 0x4079d2
movl -0x4(%rsp), %eax
movl %eax, 0x8(%rdi)
movq -0xc(%rsp), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: reflect
void reflect(float *out,const float *II,const float *N) {
  //I - 2.0 * dot(N, I) * N.

  float a=2.0f*vec3_dot(N,II);
  out[0]=II[0]-a*N[0];
  out[1]=II[1]-a*N[1];
  out[2]=II[2]-a*N[2];

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x406f00
mulss 0xcc201(%rip), %xmm0    # 0x4d3c34
movss (%rbx), %xmm1
mulss %xmm0, %xmm1
addss (%r14), %xmm1
movss %xmm1, (%r15)
movss 0x4(%rbx), %xmm1
mulss %xmm0, %xmm1
addss 0x4(%r14), %xmm1
movss %xmm1, 0x4(%r15)
mulss 0x8(%rbx), %xmm0
addss 0x8(%r14), %xmm0
movss %xmm0, 0x8(%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: intersectRayPlane
bool intersectRayPlane(const float *P,const float *V,
                       const float *plane,float *t) {
  //ax+by+cz+d=0
  float d, NPd, NV;
  const float *N;

  //
  d=plane[3];
  N=plane;

  //
  NPd=vec3_dot(N,P)+d;

  //origin below plane
  //and on
  if(NPd <= 0.0f) {
    return false;
  }

  //
  NV=vec3_dot(N,V);

  //vector parallel or pointing away from plane
  if(NV >= 0.0f) {
    return false;
  }


  //
  (*t)=-(NPd)/NV;

  //
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rsi
movss 0xc(%rdx), %xmm0
movss %xmm0, (%rsp)
movq %rdx, %rdi
callq 0x406f00
addss (%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x407ce7
movaps %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x406f00
ucomiss 0xca7be(%rip), %xmm0    # 0x4d248c
jae 0x407ce7
movaps (%rsp), %xmm1
xorps 0xcbf75(%rip), %xmm1    # 0x4d3c50
divss %xmm0, %xmm1
movss %xmm1, (%rbx)
movb $0x1, %al
jmp 0x407ce9
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: intersectRaySphere
bool intersectRaySphere(const float *P,const float *V,
                        const float *C,float r,
                        float *t) {
  float M[3],b,d,c;

  //
  vec3_sub(M,P,C);
  c=vec3_dot(M,M)-r*r;

  //inside sphere
  if(c<0.0f) {
    return false;
  }

  //
  b=vec3_dot(V,M);

  //ray pointing away from sphere
  // when on or outside sphere (c>=0)
  if(b > 0.0f) {
    return false;
  }

  //
  d=b*b-c;

  //no real roots (ray pointing towards, but misses)
  if(d < 0.0f) {
    return false;
  }

  //
  (*t)=-b-sqrtf(d);

  //
  return true;
}

// Assembly:
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm2
subss (%rdx), %xmm1
subss 0x4(%rdx), %xmm2
movss 0x8(%rdi), %xmm5
subss 0x8(%rdx), %xmm5
movaps %xmm2, %xmm3
mulss %xmm2, %xmm3
movaps %xmm1, %xmm4
mulss %xmm1, %xmm4
addss %xmm3, %xmm4
movaps %xmm5, %xmm3
mulss %xmm5, %xmm3
addss %xmm4, %xmm3
mulss %xmm0, %xmm0
subss %xmm0, %xmm3
xorps %xmm0, %xmm0
ucomiss %xmm3, %xmm0
ja 0x407d6a
mulss 0x4(%rsi), %xmm2
mulss (%rsi), %xmm1
mulss 0x8(%rsi), %xmm5
addss %xmm2, %xmm1
addss %xmm1, %xmm5
ucomiss %xmm0, %xmm5
ja 0x407d6a
movaps %xmm5, %xmm0
mulss %xmm5, %xmm0
subss %xmm3, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x407d6d
xorl %eax, %eax
retq
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
xorps 0xcbed4(%rip), %xmm5    # 0x4d3c50
ucomiss %xmm1, %xmm0
jb 0x407d87
sqrtss %xmm0, %xmm0
jmp 0x407d94
movaps %xmm5, (%rsp)
callq 0x415a50
movaps (%rsp), %xmm5
subss %xmm0, %xmm5
movss %xmm5, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/archer1357[P]Offline-Raytracer/math.c
// Function: intersectRayBox
bool intersectRayBox(const float *P,const float *invV,
                     const float *boxMin,const float *boxMax,
                     float *h0,float *h1) {

  //from libdimension
  // This is actually correct, even though it appears not to handle edge cases
  // (line.n.{x,y,z} == 0).  It works because the infinities that result from
  // dividing by zero will still behave correctly in the comparisons.  Lines
  // which are parallel to an axis and outside the box will have tmin == inf
  // or tmax == -inf, while lines inside the box will have tmin and tmax
  // unchanged.
  float t=INFINITY;
  float tx1 = (boxMin[0] - P[0])*invV[0];
  float tx2 = (boxMax[0] - P[0])*invV[0];

  float tmin = minOf(tx1, tx2);
  float tmax = maxOf(tx1, tx2);

  float ty1 = (boxMin[1] - P[1])*invV[1];
  float ty2 = (boxMax[1] - P[1])*invV[1];

  tmin = maxOf(tmin, minOf(ty1, ty2));
  tmax = minOf(tmax, maxOf(ty1, ty2));

  float tz1 = (boxMin[2] - P[2])*invV[2];
  float tz2 = (boxMax[2] - P[2])*invV[2];

  tmin = maxOf(tmin, minOf(tz1, tz2));
  tmax = minOf(tmax, maxOf(tz1, tz2));
  *h0=maxOf(0.0f,tmin);
  *h1=tmax;
  return tmax >= maxOf(0.0f, tmin) && tmin < t;
}

// Assembly:
movsd (%rdx), %xmm1
movsd (%rdi), %xmm0
subps %xmm0, %xmm1
movsd (%rsi), %xmm2
mulps %xmm2, %xmm1
movsd (%rcx), %xmm3
subps %xmm0, %xmm3
mulps %xmm2, %xmm3
movaps %xmm3, %xmm0
minps %xmm1, %xmm0
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2     # xmm2 = xmm2[1,1],xmm0[1,1]
maxss %xmm2, %xmm0
maxps %xmm3, %xmm1
movaps %xmm1, %xmm2
shufps $0x55, %xmm1, %xmm2     # xmm2 = xmm2[1,1],xmm1[1,1]
minss %xmm1, %xmm2
movss 0x8(%rdx), %xmm1
movss 0x8(%rdi), %xmm3
subss %xmm3, %xmm1
movss 0x8(%rsi), %xmm4
mulss %xmm4, %xmm1
movss 0x8(%rcx), %xmm5
subss %xmm3, %xmm5
mulss %xmm4, %xmm5
movaps %xmm5, %xmm3
minss %xmm1, %xmm3
maxss %xmm3, %xmm0
maxss %xmm5, %xmm1
minss %xmm2, %xmm1
xorps %xmm2, %xmm2
maxss %xmm0, %xmm2
movss %xmm2, (%r8)
ucomiss %xmm2, %xmm1
setae %cl
ucomiss 0xcb895(%rip), %xmm0    # 0x4d3910
movss %xmm1, (%r9)
setne %al
andb %cl, %al
retq