LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xcfd42(%rip), %xmm6    # 0x4d54c0
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 0xcfd13(%rip), %xmm4    # 0x4d54c4
mulss 0xcfd0f(%rip), %xmm3    # 0x4d54c8
mulss 0xcfd0b(%rip), %xmm1    # 0x4d54cc
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_O1/archer1357[P]Offline-Raytracer/kdtree.c
// Function: calcBoundingBoxSa
float calcBoundingBoxSa(const float *start,const float *end) {
  float diag[3];
  diag[0]=end[0]-start[0];
  diag[1]=end[1]-start[1];
  diag[2]=end[2]-start[2];
  return 2.0f*(diag[0]*diag[1]+diag[0]*diag[2]+diag[1]*diag[2]);
}

// Assembly:
movss (%rsi), %xmm1
movss 0x4(%rsi), %xmm2
subss (%rdi), %xmm1
subss 0x4(%rdi), %xmm2
movss 0x8(%rsi), %xmm0
subss 0x8(%rdi), %xmm0
movaps %xmm1, %xmm3
mulss %xmm0, %xmm3
mulss %xmm2, %xmm1
addss %xmm3, %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
addss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/kdtree.c
// Function: calcBoundingBoxMaximumExtent
int calcBoundingBoxMaximumExtent(const float *start,const float *end) {
  float diag[3];

  diag[0]=end[0]-start[0];
  diag[1]=end[1]-start[1];
  diag[2]=end[2]-start[2];

  if (diag[0] > diag[1] && diag[0] > diag[2]) {
    return 0;
  } else if (diag[1] > diag[2]) {
    return 1;
  }

  return 2;
}

// Assembly:
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
subss (%rdi), %xmm0
subss 0x4(%rdi), %xmm1
movss 0x8(%rsi), %xmm2
subss 0x8(%rdi), %xmm2
xorl %ecx, %ecx
ucomiss %xmm2, %xmm1
cmpltps %xmm0, %xmm2
cmpltps %xmm0, %xmm1
andps %xmm2, %xmm1
movd %xmm1, %edx
setbe %cl
incl %ecx
xorl %eax, %eax
testb $0x1, %dl
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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), %xmm6
ucomiss %xmm6, %xmm0
jbe 0x4059cb
movss (%r8,%rax,4), %xmm5
ucomiss %xmm0, %xmm5
jbe 0x4059cb
movss (%r8), %xmm7
subss (%rcx), %xmm7
movss %xmm7, -0xc(%rsp)
movss 0x4(%r8), %xmm7
subss 0x4(%rcx), %xmm7
movss %xmm7, -0x8(%rsp)
movss 0x8(%r8), %xmm7
subss 0x8(%rcx), %xmm7
movss %xmm7, -0x4(%rsp)
leal 0x1(%rdi), %eax
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
leal (%rax,%rax,2), %eax
negl %eax
addl %edi, %eax
incl %eax
movl %edi, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
imulq $0x55555556, %rcx, %rcx # imm = 0x55555556
movq %rcx, %r8
shrq $0x3f, %r8
shrq $0x20, %rcx
addl %r8d, %ecx
leal (%rcx,%rcx,2), %ecx
negl %ecx
addl %edi, %ecx
addl $0x2, %ecx
cltq
movss -0xc(%rsp,%rax,4), %xmm7
movslq %ecx, %rax
movss -0xc(%rsp,%rax,4), %xmm8
subss %xmm0, %xmm5
subss %xmm6, %xmm0
movaps %xmm7, %xmm6
addss %xmm8, %xmm6
mulss %xmm6, %xmm0
mulss %xmm8, %xmm7
addss %xmm7, %xmm0
addss %xmm0, %xmm0
mulss %xmm5, %xmm6
addss %xmm7, %xmm6
addss %xmm6, %xmm6
movss 0xcfb10(%rip), %xmm7    # 0x4d5490
movaps %xmm7, %xmm5
subss %xmm2, %xmm5
movaps %xmm5, %xmm2
testl %edx, %edx
je 0x405991
movaps %xmm7, %xmm2
mulss %xmm1, %xmm0
mulss %xmm1, %xmm6
testl %esi, %esi
je 0x4059a0
movaps %xmm2, %xmm5
cvtsi2ss %edx, %xmm1
xorps %xmm2, %xmm2
cvtsi2ss %esi, %xmm2
mulss %xmm4, %xmm5
mulss %xmm1, %xmm0
mulss %xmm2, %xmm6
addss %xmm0, %xmm6
mulss %xmm5, %xmm6
addss %xmm3, %xmm6
movss %xmm6, (%r9)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %esi, %esi
je 0x405f4a
movl $0x1, %ecx
movl $0x1, %eax
movl %esi, %edx
testb $0x1, %sil
movl %edi, %r8d
cmovel %ecx, %r8d
imull %r8d, %eax
sarl %edx
imull %edi, %edi
cmpl $0x1, %esi
movl %edx, %esi
ja 0x405f2e
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcdfdb(%rip), %xmm0    # 0x4d54b8
mulss %xmm1, %xmm0
mulss %xmm1, %xmm0
addss 0xcf753(%rip), %xmm0    # 0x4d6c40
mulss %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss 0x8(%rdx), %xmm2
movss 0x8(%rsi), %xmm3
movss (%rdx), %xmm4
movss 0x4(%rdx), %xmm5
movaps %xmm1, %xmm6
mulss %xmm2, %xmm6
mulss %xmm0, %xmm2
mulss %xmm5, %xmm0
mulss %xmm3, %xmm5
subss %xmm5, %xmm6
mulss %xmm4, %xmm3
subss %xmm2, %xmm3
mulss %xmm1, %xmm4
subss %xmm4, %xmm0
movss %xmm6, (%rdi)
movss %xmm3, 0x4(%rdi)
movss %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movss (%rsi), %xmm1
movss 0x4(%rsi), %xmm0
mulss %xmm0, %xmm0
mulss %xmm1, %xmm1
addss %xmm0, %xmm1
movss 0x8(%rsi), %xmm0
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x4075d6
sqrtss %xmm0, %xmm0
jmp 0x4075db
callq 0x4182c0
movss 0xcdead(%rip), %xmm1    # 0x4d5490
divss %xmm0, %xmm1
movss (%r14), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rbx)
movss 0x4(%r14), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
mulss 0x8(%r14), %xmm1
movss %xmm1, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0x10(%rdi), %rax
leaq 0x10(%rsi), %rcx
addq $0x4, %rdi
addq $0x4, %rsi
movl $0x3, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq $0x2, %r9
ja 0x40772c
movq %rdx, %r10
movq %rsi, %r11
movq %rdi, %rbx
movq %rcx, %r14
movq %rax, %r15
movss (%r11,%r8), %xmm0
movss (%r14,%r8), %xmm1
movss %xmm1, (%rbx,%r8)
movss %xmm0, (%r15,%r8)
addq $0x10, %r15
addq $0x10, %r14
addq $0x4, %rbx
addq $0x4, %r11
decq %r10
jne 0x4076ff
incq %r9
addq $0x14, %r8
decq %rdx
cmpq $0x4, %r9
jne 0x4076ea
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq (,%rax,4), %rcx
movq %rdx, %r8
xorl %r9d, %r9d
xorps %xmm0, %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x10, %r10
jne 0x407758
leaq (%r9,%rcx), %r10
movss %xmm0, -0x48(%rsp,%r10,4)
incq %r9
addq $0x4, %r8
cmpq $0x4, %r9
jne 0x407752
incq %rax
addq $0x10, %rsi
cmpq $0x4, %rax
jne 0x407744
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_O1/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
movl $0x0, -0x18(%rsp,%rax,4)
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movss (%rsi,%rcx,4), %xmm1
mulss (%rdx,%rcx,4), %xmm1
addss %xmm1, %xmm0
incq %rcx
cmpq $0x4, %rcx
jne 0x4077ca
movss %xmm0, -0x18(%rsp,%rax,4)
incq %rax
addq $0x10, %rsi
cmpq $0x4, %rax
jne 0x4077bd
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq $-0x40, %rax
xorl %ecx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movss 0xcdc7c(%rip), %xmm0    # 0x4d5490
xorl %r8d, %r8d
movl %ecx, %r9d
imulq %rdx, %r9
shrq $0x22, %r9
leal (%r9,%r9,4), %r9d
movaps %xmm0, %xmm1
addl %r8d, %r9d
je 0x407831
xorps %xmm1, %xmm1
movss %xmm1, -0x40(%rsp,%rax)
decl %r8d
incl %ecx
addq $0x4, %rax
jne 0x407817
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
leaq -0x40(%rsp), %rax
movaps %xmm3, 0x30(%rax)
movaps %xmm2, 0x20(%rax)
movaps %xmm1, 0x10(%rax)
movaps %xmm0, (%rax)
leaq -0x80(%rsp), %rcx
xorl %edx, %edx
movaps 0xcf3dd(%rip), %xmm0    # 0x4d6c50
movq %rax, %rsi
movq %rcx, %r8
leaq (%rdx,%rdx,4), %r9
movss -0x40(%rsp,%r9,4), %xmm1
xorl %r9d, %r9d
movss (%rsi,%r9,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%rsi,%r9,4)
movss (%r8,%r9,4), %xmm2
divss %xmm1, %xmm2
movss %xmm2, (%r8,%r9,4)
incq %r9
cmpq $0x4, %r9
jne 0x407887
movq %rax, %r9
movq %rcx, %r10
xorl %r11d, %r11d
cmpq %r11, %rdx
je 0x407908
movq %r11, %rbx
shlq $0x4, %rbx
leaq (%rbx,%rdx,4), %rbx
movss -0x40(%rsp,%rbx), %xmm1
xorps %xmm0, %xmm1
xorl %ebx, %ebx
movss (%rsi,%rbx,4), %xmm2
mulss %xmm1, %xmm2
addss (%r9,%rbx,4), %xmm2
movss (%r8,%rbx,4), %xmm3
mulss %xmm1, %xmm3
addss (%r10,%rbx,4), %xmm3
movss %xmm2, (%r9,%rbx,4)
movss %xmm3, (%r10,%rbx,4)
incq %rbx
cmpq $0x4, %rbx
jne 0x4078d4
incq %r11
addq $0x10, %r10
addq $0x10, %r9
cmpq $0x4, %r11
jne 0x4078b9
incq %rdx
addq $0x10, %r8
addq $0x10, %rsi
cmpq $0x4, %rdx
jne 0x407879
movaps -0x80(%rsp), %xmm0
movaps -0x70(%rsp), %xmm1
movaps -0x60(%rsp), %xmm2
movaps -0x50(%rsp), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4077fd
movl $0x3, %eax
xorl %ecx, %ecx
cmpq $0x2, %rcx
ja 0x40799e
movl $0x4, %edx
movq %rax, %rsi
movss (%r14,%rdx), %xmm0
movss (%r14,%rdx,4), %xmm1
movss %xmm1, (%r14,%rdx)
movss %xmm0, (%r14,%rdx,4)
addq $0x4, %rdx
decq %rsi
jne 0x40797d
incq %rcx
addq $0x14, %r14
decq %rax
cmpq $0x4, %rcx
jne 0x40796f
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 $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x48, %rsp
movq $-0x40, %rax
xorl %ecx, %ecx
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
movss 0xcda72(%rip), %xmm0    # 0x4d5490
xorl %r9d, %r9d
movl %ecx, %r10d
imulq %r8, %r10
shrq $0x22, %r10
leal (%r10,%r10,4), %r10d
movaps %xmm0, %xmm1
addl %r9d, %r10d
je 0x407a3b
xorps %xmm1, %xmm1
movss %xmm1, 0x40(%rsp,%rax)
decl %r9d
incl %ecx
addq $0x4, %rax
jne 0x407a21
movl $0x3, %eax
movss -0x3(%rsi,%rax), %xmm0
movss %xmm0, (%rsp,%rax,4)
addq $0x4, %rax
cmpq $0xf, %rax
jne 0x407a51
testb %dl, %dl
je 0x407a77
movq %rsp, %rdx
movq %rdi, %rsi
callq 0x407742
jmp 0x407a99
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
subq $0x48, %rsp
movq $-0x40, %rax
xorl %ecx, %ecx
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
movss 0xcd9d7(%rip), %xmm0    # 0x4d5490
xorl %r9d, %r9d
movl %ecx, %r10d
imulq %r8, %r10
shrq $0x22, %r10
leal (%r10,%r10,4), %r10d
movaps %xmm0, %xmm1
addl %r9d, %r10d
je 0x407ad6
xorps %xmm1, %xmm1
movss %xmm1, 0x40(%rsp,%rax)
decl %r9d
incl %ecx
addq $0x4, %rax
jne 0x407abc
xorl %eax, %eax
movss (%rsi), %xmm0
movss %xmm0, (%rsp,%rax,4)
addq $0x5, %rax
addq $0x4, %rsi
cmpq $0xf, %rax
jne 0x407ae9
testb %dl, %dl
je 0x407b11
movq %rsp, %rdx
movq %rdi, %rsi
callq 0x407742
jmp 0x407b33
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movaps 0x30(%rsp), %xmm3
movups %xmm3, 0x30(%rdi)
movups %xmm2, 0x20(%rdi)
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq $-0x40, %rax
xorl %ecx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movss 0xcd937(%rip), %xmm2    # 0x4d5490
xorl %esi, %esi
movl %ecx, %edi
imulq %rdx, %rdi
shrq $0x22, %rdi
leal (%rdi,%rdi,4), %edi
movaps %xmm2, %xmm1
addl %esi, %edi
je 0x407b72
xorps %xmm1, %xmm1
movss %xmm1, 0x50(%rsp,%rax)
decl %esi
incl %ecx
addq $0x4, %rax
jne 0x407b5b
movss %xmm0, 0x8(%rsp)
callq 0x401078
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x401118
movss 0xc(%rsp), %xmm2
movss %xmm2, 0x24(%rsp)
movaps 0xcf09f(%rip), %xmm1    # 0x4d6c50
xorps %xmm0, %xmm1
movss %xmm1, 0x28(%rsp)
movss %xmm0, 0x34(%rsp)
movss %xmm2, 0x38(%rsp)
testb %bpl, %bpl
je 0x407bdd
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407742
jmp 0x407c00
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 $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq $-0x40, %rax
xorl %ecx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movss 0xcd868(%rip), %xmm2    # 0x4d5490
xorl %esi, %esi
movl %ecx, %edi
imulq %rdx, %rdi
shrq $0x22, %rdi
leal (%rdi,%rdi,4), %edi
movaps %xmm2, %xmm1
addl %esi, %edi
je 0x407c41
xorps %xmm1, %xmm1
movss %xmm1, 0x50(%rsp,%rax)
decl %esi
incl %ecx
addq $0x4, %rax
jne 0x407c2a
movss %xmm0, 0x8(%rsp)
callq 0x401078
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x401118
movss 0xc(%rsp), %xmm1
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0x18(%rsp)
xorps 0xcefca(%rip), %xmm0    # 0x4d6c50
movss %xmm0, 0x30(%rsp)
movss %xmm1, 0x38(%rsp)
testb %bpl, %bpl
je 0x407ca9
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407742
jmp 0x407ccc
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 $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq $-0x40, %rax
xorl %ecx, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movss 0xcd79c(%rip), %xmm2    # 0x4d5490
xorl %esi, %esi
movl %ecx, %edi
imulq %rdx, %rdi
shrq $0x22, %rdi
leal (%rdi,%rdi,4), %edi
movaps %xmm2, %xmm1
addl %esi, %edi
je 0x407d0d
xorps %xmm1, %xmm1
movss %xmm1, 0x50(%rsp,%rax)
decl %esi
incl %ecx
addq $0x4, %rax
jne 0x407cf6
movss %xmm0, 0x8(%rsp)
callq 0x401078
movss %xmm0, 0xc(%rsp)
movss 0x8(%rsp), %xmm0
callq 0x401118
movss 0xc(%rsp), %xmm2
movss %xmm2, 0x10(%rsp)
movaps 0xcef04(%rip), %xmm1    # 0x4d6c50
xorps %xmm0, %xmm1
movss %xmm1, 0x14(%rsp)
movss %xmm0, 0x20(%rsp)
movss %xmm2, 0x24(%rsp)
testb %bpl, %bpl
je 0x407d78
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x407742
jmp 0x407d9b
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 $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x0, -0xc(%rsp,%rax,4)
xorps %xmm0, %xmm0
xorl %ecx, %ecx
movss (%rsi,%rcx,4), %xmm1
mulss (%rdx,%rcx,4), %xmm1
addss %xmm1, %xmm0
incq %rcx
cmpq $0x3, %rcx
jne 0x4082a6
movss %xmm0, -0xc(%rsp,%rax,4)
incq %rax
addq $0xc, %rsi
cmpq $0x3, %rax
jne 0x408299
movl -0x4(%rsp), %eax
movl %eax, 0x8(%rdi)
movq -0xc(%rsp), %rax
movq %rax, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movss (%rsi), %xmm0
movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm2
mulss 0x4(%rsi), %xmm2
movaps %xmm1, %xmm3
mulss %xmm0, %xmm3
movss 0x8(%rdx), %xmm4
mulss 0x8(%rsi), %xmm4
addss %xmm2, %xmm3
addss %xmm3, %xmm4
mulss 0xce931(%rip), %xmm4    # 0x4d6c44
mulss %xmm4, %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdi)
movss 0x4(%rdx), %xmm0
mulss %xmm4, %xmm0
addss 0x4(%rsi), %xmm0
movss %xmm0, 0x4(%rdi)
mulss 0x8(%rdx), %xmm4
addss 0x8(%rsi), %xmm4
movss %xmm4, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x408633
mulss 0x4(%rsi), %xmm2
mulss (%rsi), %xmm1
mulss 0x8(%rsi), %xmm5
addss %xmm2, %xmm1
addss %xmm1, %xmm5
ucomiss %xmm0, %xmm5
ja 0x408633
movaps %xmm5, %xmm0
mulss %xmm5, %xmm0
subss %xmm3, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x408636
xorl %eax, %eax
retq
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
xorps 0xce60b(%rip), %xmm5    # 0x4d6c50
ucomiss %xmm1, %xmm0
jb 0x408650
sqrtss %xmm0, %xmm0
jmp 0x40865d
movaps %xmm5, (%rsp)
callq 0x4182c0
movaps (%rsp), %xmm5
subss %xmm0, %xmm5
movss %xmm5, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movss (%rdx), %xmm2
movss 0x4(%rdx), %xmm0
movss (%rdi), %xmm1
movss 0x4(%rdi), %xmm3
subss %xmm1, %xmm2
movss (%rsi), %xmm4
movss 0x4(%rsi), %xmm5
mulss %xmm4, %xmm2
movss (%rcx), %xmm6
movss 0x4(%rcx), %xmm7
subss %xmm1, %xmm6
mulss %xmm4, %xmm6
movaps %xmm6, %xmm1
minss %xmm2, %xmm1
maxss %xmm6, %xmm2
subss %xmm3, %xmm0
mulss %xmm5, %xmm0
subss %xmm3, %xmm7
mulss %xmm5, %xmm7
movaps %xmm7, %xmm3
minss %xmm0, %xmm3
maxss %xmm3, %xmm1
maxss %xmm7, %xmm0
minss %xmm2, %xmm0
movss 0x8(%rdx), %xmm2
movss 0x8(%rdi), %xmm3
subss %xmm3, %xmm2
movss 0x8(%rsi), %xmm4
mulss %xmm4, %xmm2
movss 0x8(%rcx), %xmm5
subss %xmm3, %xmm5
mulss %xmm4, %xmm5
movaps %xmm5, %xmm3
minss %xmm2, %xmm3
maxss %xmm3, %xmm1
maxss %xmm5, %xmm2
minss %xmm0, %xmm2
xorps %xmm0, %xmm0
maxss %xmm1, %xmm0
movss %xmm0, (%r8)
ucomiss %xmm0, %xmm2
setae %cl
ucomiss 0xce01a(%rip), %xmm1    # 0x4d6944
movss %xmm2, (%r9)
setne %al
andb %cl, %al
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: planeFromPointNormal
void planeFromPointNormal(const float *pt,
                          const float *nor,
                          bool norm,
                          float *plane) {

  //ax+by+cz+d=0

  plane[0]=nor[0]; //a
  plane[1]=nor[1]; //b
  plane[2]=nor[2]; //c

  if(norm) {
    vec3_normal(plane,plane);
  }

  plane[3]=-vec3_dot(pt,plane);//d
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movss (%rsi), %xmm1
movss %xmm1, (%rcx)
movss 0x4(%rsi), %xmm2
movss %xmm2, 0x4(%rcx)
movss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rcx)
testl %edx, %edx
je 0x4089b6
mulss %xmm2, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x408981
sqrtss %xmm0, %xmm0
jmp 0x408986
callq 0x4182c0
movss 0xccb02(%rip), %xmm1    # 0x4d5490
divss %xmm0, %xmm1
movss (%rbx), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, (%rbx)
movss 0x4(%rbx), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rbx)
mulss 0x8(%rbx), %xmm1
movss %xmm1, 0x8(%rbx)
movss (%r14), %xmm0
movss 0x4(%r14), %xmm1
mulss 0x4(%rbx), %xmm1
mulss (%rbx), %xmm0
addss %xmm1, %xmm0
movss 0x8(%r14), %xmm1
mulss 0x8(%rbx), %xmm1
addss %xmm0, %xmm1
xorps 0xce26c(%rip), %xmm1    # 0x4d6c50
movss %xmm1, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: planeFromTriangle
void planeFromTriangle(const float *pt0,const float *pt1,
                       const float *pt2,bool cw,
                       float *plane) {

  float E0[3],E1[3],N[3];
  vec3_sub(E0,pt1,pt0);
  vec3_sub(E1,pt2,pt0);
  vec3_cross(N,E0,E1);
  vec3_normal(N,N);

  if(!cw) {
    vec3_mulScalar(N,N,-1.0f);
  }

  planeFromPointNormal(pt0,N,false,plane);


}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdi, %r14
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss (%rdi), %xmm2
movss 0x4(%rdi), %xmm3
subss %xmm2, %xmm0
subss %xmm3, %xmm1
movss 0x8(%rsi), %xmm7
movss 0x8(%rdi), %xmm4
subss %xmm4, %xmm7
movss (%rdx), %xmm5
movss 0x4(%rdx), %xmm6
subss %xmm2, %xmm5
subss %xmm3, %xmm6
movss 0x8(%rdx), %xmm2
subss %xmm4, %xmm2
movaps %xmm6, %xmm3
mulss %xmm7, %xmm3
mulss %xmm5, %xmm7
mulss %xmm1, %xmm5
movaps %xmm1, %xmm4
mulss %xmm2, %xmm4
subss %xmm3, %xmm4
mulss %xmm0, %xmm2
subss %xmm2, %xmm7
mulss %xmm0, %xmm6
subss %xmm5, %xmm6
movaps %xmm7, %xmm0
mulss %xmm7, %xmm0
movaps %xmm4, %xmm1
mulss %xmm4, %xmm1
addss %xmm0, %xmm1
movaps %xmm6, %xmm0
mulss %xmm6, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x408a98
sqrtss %xmm0, %xmm0
jmp 0x408ab9
movaps %xmm6, 0x20(%rsp)
movaps %xmm7, 0x10(%rsp)
movaps %xmm4, (%rsp)
callq 0x4182c0
movaps (%rsp), %xmm4
movaps 0x10(%rsp), %xmm7
movaps 0x20(%rsp), %xmm6
movss 0xcc9cf(%rip), %xmm1    # 0x4d5490
divss %xmm0, %xmm1
mulss %xmm1, %xmm4
mulss %xmm1, %xmm7
mulss %xmm1, %xmm6
movaps 0xce178(%rip), %xmm0    # 0x4d6c50
testb %bpl, %bpl
jne 0x408ae6
xorps %xmm0, %xmm4
xorps %xmm0, %xmm7
xorps %xmm0, %xmm6
movss %xmm4, (%rbx)
movss %xmm7, 0x4(%rbx)
movss %xmm6, 0x8(%rbx)
mulss 0x4(%r14), %xmm7
mulss (%r14), %xmm4
mulss 0x8(%r14), %xmm6
addss %xmm7, %xmm4
addss %xmm4, %xmm6
xorps %xmm0, %xmm6
movss %xmm6, 0xc(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: triangleBoundingBox
void triangleBoundingBox(const float *pt0,
                         const float *pt1,
                         const float *pt2,
                         float *start,float *end) {
  int i;

  start[0]=end[0]=pt0[0];
  start[1]=end[1]=pt0[1];
  start[2]=end[2]=pt0[2];

  for(i=0;i<3;i++) {
    if(pt1[i] < start[i]) {
      start[i]=pt1[i];
    }

    if(pt1[i] > end[i]) {
      end[i]=pt1[i];
    }

    if(pt2[i] < start[i]) {
      start[i]=pt2[i];
    }

    if(pt2[i] > end[i]) {
      end[i]=pt2[i];
    }
  }
}

// Assembly:
movss (%rdi), %xmm0
movss %xmm0, (%r8)
movss %xmm0, (%rcx)
movss 0x4(%rdi), %xmm0
movss %xmm0, 0x4(%r8)
movss %xmm0, 0x4(%rcx)
movss 0x8(%rdi), %xmm0
movss %xmm0, 0x8(%r8)
movss %xmm0, 0x8(%rcx)
xorl %eax, %eax
movss (%rsi,%rax,4), %xmm0
movss (%rcx,%rax,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x408b61
movss %xmm0, (%rcx,%rax,4)
movss (%rsi,%rax,4), %xmm0
ucomiss (%r8,%rax,4), %xmm0
jbe 0x408b73
movss %xmm0, (%r8,%rax,4)
movss (%rdx,%rax,4), %xmm0
movss (%rcx,%rax,4), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x408b87
movss %xmm0, (%rcx,%rax,4)
movss (%rdx,%rax,4), %xmm0
ucomiss (%r8,%rax,4), %xmm0
jbe 0x408b99
movss %xmm0, (%r8,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x408b4d
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: sphereBoundingBox
void sphereBoundingBox(const float *pos,float radius,
                       float *start,float *end) {
  int i;

  for(i=0;i<3;i++) {
    start[i]=pos[i]-radius;
    end[i]=pos[i]+radius;
  }
}

// Assembly:
xorl %eax, %eax
movss (%rdi,%rax,4), %xmm1
subss %xmm0, %xmm1
movss %xmm1, (%rsi,%rax,4)
movss (%rdi,%rax,4), %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%rdx,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x408ba5
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_frustum
void mat4_frustum(float *out,
                  float left,float right,
                  float bottom,float top,
                  float zNear,float zFar) {

  memset(out,0,sizeof(float)*16);

  float A=(right+left)/(right-left);
  float B=(top+bottom)/(top-bottom);
  float C=-(zFar+zNear)/(zFar-zNear);
  float D=-(2.0f*zFar*zNear)/(zFar-zNear);

  float x=(2.0f*zNear)/(right-left);
  float y=(2.0f*zNear)/(top-bottom);

  out[0]=x;
  out[2]=A;
  out[5]=y;
  out[6]=B;
  out[10]=C;
  out[11]=D;
  out[14]=-1.0f;
}

// Assembly:
xorps %xmm6, %xmm6
movups %xmm6, (%rdi)
movups %xmm6, 0x10(%rdi)
movups %xmm6, 0x20(%rdi)
movups %xmm6, 0x30(%rdi)
movaps %xmm0, %xmm6
addss %xmm1, %xmm6
subss %xmm0, %xmm1
divss %xmm1, %xmm6
movaps %xmm2, %xmm0
addss %xmm3, %xmm0
subss %xmm2, %xmm3
divss %xmm3, %xmm0
movaps %xmm4, %xmm2
addss %xmm5, %xmm2
xorps 0xce015(%rip), %xmm2    # 0x4d6c50
movaps %xmm5, %xmm7
subss %xmm4, %xmm7
divss %xmm7, %xmm2
mulss 0xcdff6(%rip), %xmm5    # 0x4d6c44
mulss %xmm4, %xmm5
divss %xmm7, %xmm5
addss %xmm4, %xmm4
movaps %xmm4, %xmm7
divss %xmm1, %xmm7
divss %xmm3, %xmm4
movss %xmm7, (%rdi)
movss %xmm6, 0x8(%rdi)
movss %xmm4, 0x14(%rdi)
movss %xmm0, 0x18(%rdi)
movss %xmm2, 0x28(%rdi)
movss %xmm5, 0x2c(%rdi)
movl $0xbf800000, 0x38(%rdi) # imm = 0xBF800000
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_infFrustum
void mat4_infFrustum(float *out,
                     float left,float right,
                     float bottom,float top,
                     float zNear) {

  memset(out,0,sizeof(float)*16);

  float A=(right+left)/(right-left);
  float B=(top+bottom)/(top-bottom);
  float C=-1.0f;
  float D=-2.0f*zNear;

  float x=(2.0f*zNear)/(right-left);
  float y=(2.0f*zNear)/(top-bottom);

  out[0]=x;
  out[2]=A;
  out[5]=y;
  out[6]=B;
  out[10]=C;
  out[11]=D;
  out[14]=-1.0f;
}

// Assembly:
xorps %xmm5, %xmm5
movups %xmm5, (%rdi)
movups %xmm5, 0x10(%rdi)
movups %xmm5, 0x20(%rdi)
movups %xmm5, 0x30(%rdi)
movaps %xmm0, %xmm5
addss %xmm1, %xmm5
subss %xmm0, %xmm1
divss %xmm1, %xmm5
movaps %xmm2, %xmm0
addss %xmm3, %xmm0
subss %xmm2, %xmm3
divss %xmm3, %xmm0
movss 0xcdf82(%rip), %xmm2    # 0x4d6c44
mulss %xmm4, %xmm2
addss %xmm4, %xmm4
movaps %xmm4, %xmm6
divss %xmm1, %xmm6
divss %xmm3, %xmm4
movss %xmm6, (%rdi)
movss %xmm5, 0x8(%rdi)
movss %xmm4, 0x14(%rdi)
movss %xmm0, 0x18(%rdi)
movl $0xbf800000, %eax       # imm = 0xBF800000
movl %eax, 0x28(%rdi)
movss %xmm2, 0x2c(%rdi)
movl %eax, 0x38(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_perspective_fovx
void mat4_perspective_fovx(float *out,
                        float fovx,float aspect,
                        float znear,float zfar) {
  float right=tan(fovx/2.0f)*znear;
  float left=-right;
  float top=right/aspect;
  float bottom=-top;
  mat4_frustum(out,left,right,bottom,top,znear,zfar);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movq %rdi, %rbx
mulss 0xcc791(%rip), %xmm0    # 0x4d54ac
cvtss2sd %xmm0, %xmm0
callq 0x4010f8
movss 0x4(%rsp), %xmm7
xorps %xmm1, %xmm1
cvtss2sd %xmm7, %xmm1
mulsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm1
movaps %xmm1, %xmm0
divss 0x8(%rsp), %xmm0
xorps %xmm2, %xmm2
movups %xmm2, (%rbx)
movups %xmm2, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm2, 0x30(%rbx)
movaps %xmm1, %xmm2
subss %xmm1, %xmm2
addss %xmm1, %xmm1
divss %xmm1, %xmm2
movaps %xmm0, %xmm3
subss %xmm0, %xmm3
addss %xmm0, %xmm0
divss %xmm0, %xmm3
movaps %xmm7, %xmm4
movss 0xc(%rsp), %xmm6
addss %xmm6, %xmm4
xorps 0xcdeca(%rip), %xmm4    # 0x4d6c50
movaps %xmm6, %xmm5
subss %xmm7, %xmm5
divss %xmm5, %xmm4
mulss 0xcdeab(%rip), %xmm6    # 0x4d6c44
mulss %xmm7, %xmm6
divss %xmm5, %xmm6
addss %xmm7, %xmm7
movaps %xmm7, %xmm5
divss %xmm1, %xmm5
divss %xmm0, %xmm7
movss %xmm5, (%rbx)
movss %xmm2, 0x8(%rbx)
movss %xmm7, 0x14(%rbx)
movss %xmm3, 0x18(%rbx)
movss %xmm4, 0x28(%rbx)
movss %xmm6, 0x2c(%rbx)
movl $0xbf800000, 0x38(%rbx) # imm = 0xBF800000
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_perspective_fovy
void mat4_perspective_fovy(float *out,
                        float fovy,float aspect,
                        float znear,float zfar) {

  float top=tan(fovy/2.0f)*znear;
  float bottom=-top;
  float right=top*aspect;
  float left=-right;
  mat4_frustum(out,left,right,bottom,top,znear,zfar);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movq %rdi, %rbx
mulss 0xcc6b0(%rip), %xmm0    # 0x4d54ac
cvtss2sd %xmm0, %xmm0
callq 0x4010f8
movss 0x4(%rsp), %xmm6
xorps %xmm1, %xmm1
cvtss2sd %xmm6, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss 0x8(%rsp), %xmm2
mulss %xmm0, %xmm2
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movaps %xmm2, %xmm1
subss %xmm2, %xmm1
addss %xmm2, %xmm2
divss %xmm2, %xmm1
movaps %xmm2, %xmm7
movaps %xmm0, %xmm2
subss %xmm0, %xmm2
addss %xmm0, %xmm0
divss %xmm0, %xmm2
movaps %xmm6, %xmm3
movss 0xc(%rsp), %xmm5
addss %xmm5, %xmm3
xorps 0xcdde2(%rip), %xmm3    # 0x4d6c50
movaps %xmm5, %xmm4
subss %xmm6, %xmm4
divss %xmm4, %xmm3
mulss 0xcddc3(%rip), %xmm5    # 0x4d6c44
mulss %xmm6, %xmm5
divss %xmm4, %xmm5
addss %xmm6, %xmm6
movaps %xmm6, %xmm4
divss %xmm7, %xmm4
divss %xmm0, %xmm6
movss %xmm4, (%rbx)
movss %xmm1, 0x8(%rbx)
movss %xmm6, 0x14(%rbx)
movss %xmm2, 0x18(%rbx)
movss %xmm3, 0x28(%rbx)
movss %xmm5, 0x2c(%rbx)
movl $0xbf800000, 0x38(%rbx) # imm = 0xBF800000
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_infPerspective_fovx
void mat4_infPerspective_fovx(float *out,
                              float fovx,float aspect,
                              float znear) {
  float right=tan(fovx/2.0f)*znear;
  float left=-right;
  float top=right/aspect;
  float bottom=-top;
  mat4_infFrustum(out,left,right,bottom,top,znear);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0xc(%rsp)
movq %rdi, %rbx
mulss 0xcc5ce(%rip), %xmm0    # 0x4d54ac
cvtss2sd %xmm0, %xmm0
callq 0x4010f8
movss 0x8(%rsp), %xmm6
xorps %xmm1, %xmm1
cvtss2sd %xmm6, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movaps %xmm0, %xmm1
divss 0xc(%rsp), %xmm1
xorps %xmm2, %xmm2
movups %xmm2, (%rbx)
movups %xmm2, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm2, 0x30(%rbx)
movaps %xmm0, %xmm2
subss %xmm0, %xmm2
addss %xmm0, %xmm0
divss %xmm0, %xmm2
movaps %xmm1, %xmm3
subss %xmm1, %xmm3
addss %xmm1, %xmm1
divss %xmm1, %xmm3
movss 0xcdd04(%rip), %xmm4    # 0x4d6c44
mulss %xmm6, %xmm4
addss %xmm6, %xmm6
movaps %xmm6, %xmm5
divss %xmm0, %xmm5
divss %xmm1, %xmm6
movss %xmm5, (%rbx)
movss %xmm2, 0x8(%rbx)
movss %xmm6, 0x14(%rbx)
movss %xmm3, 0x18(%rbx)
movl $0xbf800000, %eax       # imm = 0xBF800000
movl %eax, 0x28(%rbx)
movss %xmm4, 0x2c(%rbx)
movl %eax, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_infPerspective_fovy
void mat4_infPerspective_fovy(float *out,
                              float fovy,float aspect,
                              float znear) {

  float top=tan(fovy/2.0f)*znear;
  float bottom=-top;
  float right=top*aspect;
  float left=-right;
  mat4_infFrustum(out,left,right,bottom,top,znear);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0xc(%rsp)
movq %rdi, %rbx
mulss 0xcc514(%rip), %xmm0    # 0x4d54ac
cvtss2sd %xmm0, %xmm0
callq 0x4010f8
movss 0x8(%rsp), %xmm5
xorps %xmm1, %xmm1
cvtss2sd %xmm5, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss 0xc(%rsp), %xmm2
mulss %xmm0, %xmm2
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movaps %xmm2, %xmm1
subss %xmm2, %xmm1
addss %xmm2, %xmm2
divss %xmm2, %xmm1
movaps %xmm2, %xmm6
movaps %xmm0, %xmm2
subss %xmm0, %xmm2
addss %xmm0, %xmm0
divss %xmm0, %xmm2
movss 0xcdc46(%rip), %xmm3    # 0x4d6c44
mulss %xmm5, %xmm3
addss %xmm5, %xmm5
movaps %xmm5, %xmm4
divss %xmm6, %xmm4
divss %xmm0, %xmm5
movss %xmm4, (%rbx)
movss %xmm1, 0x8(%rbx)
movss %xmm5, 0x14(%rbx)
movss %xmm2, 0x18(%rbx)
movl $0xbf800000, %eax       # imm = 0xBF800000
movl %eax, 0x28(%rbx)
movss %xmm3, 0x2c(%rbx)
movl %eax, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_perspective
void mat4_perspective(float *out,float fov,float aspect,
                      float znear,float zfar) {
  float yScale=1.0f/tanf(fov/2.0f);
  float xScale=yScale/aspect;
  float nearmfar=znear-zfar;

  memset(out,0,sizeof(float)*16);

  out[0]=xScale;
  out[5]=yScale;
  out[10]=(zfar+znear)/nearmfar;
  out[11]=2.0f*zfar*znear/nearmfar;
  out[14]=-1.0f;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movq %rdi, %rbx
mulss 0xcc450(%rip), %xmm0    # 0x4d54ac
callq 0x418150
movss 0xcc427(%rip), %xmm1    # 0x4d5490
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
divss 0x4(%rsp), %xmm0
movss 0x8(%rsp), %xmm4
movaps %xmm4, %xmm2
movss 0xc(%rsp), %xmm5
subss %xmm5, %xmm2
xorps %xmm3, %xmm3
movups %xmm3, (%rbx)
movups %xmm3, 0x10(%rbx)
movups %xmm3, 0x20(%rbx)
movups %xmm3, 0x30(%rbx)
movss %xmm0, (%rbx)
movss %xmm1, 0x14(%rbx)
movaps %xmm4, %xmm0
movaps %xmm5, %xmm1
addss %xmm5, %xmm0
divss %xmm2, %xmm0
movss %xmm0, 0x28(%rbx)
addss %xmm5, %xmm1
mulss %xmm4, %xmm1
divss %xmm2, %xmm1
movss %xmm1, 0x2c(%rbx)
movl $0xbf800000, 0x38(%rbx) # imm = 0xBF800000
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_perspectiveInf
void mat4_perspectiveInf(float *out,float fov,float aspect,float znear) {
  float yScale=1.0f/tanf(fov/2.0f);
  float xScale=yScale/aspect;

  memset(out,0,sizeof(float)*16);

  out[0]=xScale;
  out[5]=yScale;
  out[10]=-1.0f;
  out[11]=-2.0f*znear;
  out[14]=-1.0f;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movss %xmm2, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movq %rdi, %rbx
mulss 0xcc3bb(%rip), %xmm0    # 0x4d54ac
callq 0x418150
movss 0xcc392(%rip), %xmm1    # 0x4d5490
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
divss 0x8(%rsp), %xmm0
xorps %xmm2, %xmm2
movups %xmm2, (%rbx)
movups %xmm2, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm2, 0x30(%rbx)
movss %xmm0, (%rbx)
movss %xmm1, 0x14(%rbx)
movl $0xbf800000, %eax       # imm = 0xBF800000
movl %eax, 0x28(%rbx)
movss 0xc(%rsp), %xmm0
mulss 0xcdb08(%rip), %xmm0    # 0x4d6c44
movss %xmm0, 0x2c(%rbx)
movl %eax, 0x38(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/math.c
// Function: mat4_ortho
void mat4_ortho(float *out,float left,float right,
                float bottom,float top,float nearVal,
                float farVal) {

  memset(out,0,sizeof(float)*16);

  float tx = -(right+left)/(right-left);
  float ty = -(top+bottom)/(top-bottom);
  float tz = -(farVal+nearVal)/(farVal-nearVal);

  out[0]=2.0f/(right-left);
  out[3]=tx;
  out[5]=2.0f/(top-bottom);
  out[7]=ty;
  out[10]=-2.0f/(nearVal-farVal);
  out[11]=tz;
  out[15]=1.0f;
}

// Assembly:
xorps %xmm6, %xmm6
movups %xmm6, (%rdi)
movups %xmm6, 0x10(%rdi)
movups %xmm6, 0x20(%rdi)
movups %xmm6, 0x30(%rdi)
movaps %xmm0, %xmm6
addss %xmm1, %xmm6
movaps 0xcdae6(%rip), %xmm7    # 0x4d6c50
xorps %xmm7, %xmm6
subss %xmm0, %xmm1
divss %xmm1, %xmm6
movaps %xmm2, %xmm0
addss %xmm3, %xmm0
xorps %xmm7, %xmm0
subss %xmm2, %xmm3
divss %xmm3, %xmm0
movaps %xmm4, %xmm2
addss %xmm5, %xmm2
xorps %xmm7, %xmm2
movaps %xmm5, %xmm7
subss %xmm4, %xmm7
divss %xmm7, %xmm2
movss 0xcdaa8(%rip), %xmm7    # 0x4d6c4c
movaps %xmm7, %xmm8
divss %xmm1, %xmm8
movss %xmm8, (%rdi)
movss %xmm6, 0xc(%rdi)
divss %xmm3, %xmm7
movss %xmm7, 0x14(%rdi)
movss %xmm0, 0x1c(%rdi)
subss %xmm5, %xmm4
movss 0xcda73(%rip), %xmm0    # 0x4d6c44
divss %xmm4, %xmm0
movss %xmm0, 0x28(%rdi)
movss %xmm2, 0x2c(%rdi)
movl $0x3f800000, 0x3c(%rdi) # imm = 0x3F800000
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbdestroy
RB_STATIC void
RB_ENTRY(destroy)(struct RB_ENTRY(tree) *rbinfo)
{
	if (rbinfo==NULL)
		return;

	if (rbinfo->rb_root!=RBNULL)
		RB_ENTRY(_destroy)(rbinfo->rb_root);
	
	free(rbinfo);
}

// Assembly:
testq %rdi, %rdi
je 0x40964e
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x10ebad(%rip), %rax    # 0x5181e8
cmpq %rax, %rdi
je 0x409645
callq 0x40964f
movq %rbx, %rdi
popq %rbx
jmp 0x444d10
retq
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/redblack.c
// Function: rb_destroy
static void
RB_ENTRY(_destroy)(struct RB_ENTRY(node) *x)
{
	if (x!=RBNULL)
	{
		if (x->left!=RBNULL)
			RB_ENTRY(_destroy)(x->left);
		if (x->right!=RBNULL)
			RB_ENTRY(_destroy)(x->right);
		RB_ENTRY(_free)(x);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x10eb88(%rip), %r14    # 0x5181e8
cmpq %r14, %rdi
je 0x40966a
callq 0x40964f
movq 0x8(%rbx), %rdi
cmpq %r14, %rdi
je 0x409678
callq 0x40964f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x444d10
// File: /workspace/github_c_makefile_star2_O1/archer1357[P]Offline-Raytracer/redblack.c
// Function: rbfind
RB_STATIC const RB_ENTRY(data_t) * 
RB_ENTRY(find)(const RB_ENTRY(data_t) *key, struct RB_ENTRY(tree) *rbinfo)
{
	struct RB_ENTRY(node) *x;

	if (rbinfo==NULL)
		return(NULL);

	/* If we have a NULL root (empty tree) then just return */
	if (rbinfo->rb_root==RBNULL)
		return(NULL);

	x=RB_ENTRY(_traverse)(0, key, rbinfo);

	return((x==RBNULL) ? NULL : RB_GET(x, key));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
testq %rsi, %rsi
je 0x4098af
leaq 0x10e956(%rip), %r14    # 0x5181e8
cmpq %r14, 0x10(%rdx)
je 0x4098af
movq %rdi, %rsi
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x4096b9
cmpq %r14, %rax
je 0x4098b1
movq 0x20(%rax), %rbx
jmp 0x4098b1
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq