LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hikmeans.c
// Function: vl_hikm_new
VlHIKMTree *
vl_hikm_new (int method)
{
  VlHIKMTree *f = vl_calloc (sizeof(VlHIKMTree), 1) ;
  f->max_niters = 200 ;
  f->method = method ;
  return f ;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x30, %edi
movl $0x1, %esi
callq 0x9a70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0xc8, 0x18(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hikmeans.c
// Function: xdelete
static void
xdelete (VlHIKMNode *node)
{
  if(node) {
    vl_uindex k ;
    if (node->children) {
      for(k = 0 ; k < vl_ikm_get_K (node->filter) ; ++k)
        xdelete (node->children[k]) ;
      vl_free (node->children) ;
    }
    if (node->filter) {
      vl_ikm_delete (node->filter) ;
    }
    vl_free(node);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1dd13
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1dcf1
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x98b0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1dce3
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1dc70
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1dc9a
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1dd09
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x9280
movq 0x10(%rsp), %rdi
callq 0x9620
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hikmeans.c
// Function: vl_hikm_init
void
vl_hikm_init (VlHIKMTree *f, vl_size M, vl_size K, vl_size depth)
{
  assert(depth > 0) ;
  assert(M > 0) ;
  assert(K > 0) ;

  xdelete (f -> root) ;
  f->root = 0;
  f->M = M ;
  f->K = K ;
  f->depth = depth ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1dc70
movq 0x20(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hikmeans.c
// Function: vl_hikm_push
void
vl_hikm_push (VlHIKMTree *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N)
{
  vl_uindex i, d ;
  vl_size M = vl_hikm_get_ndims (f) ;
  vl_size depth = vl_hikm_get_depth (f) ;

  /* for each datum */
  for(i = 0 ; i < N ; i++) {
    VlHIKMNode *node = f->root ;
    d = 0 ;
    while (node) {
      vl_uint32 best ;
      vl_ikm_push (node->filter,
                   &best,
                   data + i * M, 1) ;
      asgn[i * depth + d] = best ;
      ++ d ;
      if (!node->children) break ;
      node = node->children [best] ;
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
callq 0x9650
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0x9840
movq %rax, 0x18(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x1e1b0
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1e19b
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
movq 0x30(%rsp), %rax
imulq 0x20(%rsp), %rax
addq %rax, %rdx
leaq 0xc(%rsp), %rsi
movl $0x1, %ecx
callq 0x9060
movl 0xc(%rsp), %edx
movq 0x48(%rsp), %rax
movq 0x30(%rsp), %rcx
imulq 0x18(%rsp), %rcx
addq 0x28(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1e180
jmp 0x1e19b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x1e116
jmp 0x1e19d
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1e0ef
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hog.c
// Function: vl_hog_delete
void
vl_hog_delete (VlHog * self)
{
  if (self->orientationX) {
    vl_free(self->orientationX) ;
    self->orientationX = NULL ;
  }

  if (self->orientationY) {
    vl_free(self->orientationY) ;
    self->orientationY = NULL ;
  }

  if (self->glyphs) {
    vl_free(self->glyphs) ;
    self->glyphs = NULL ;
  }

  if (self->permutation) {
    vl_free(self->permutation) ;
    self->permutation = NULL ;
  }

  if (self->hog) {
    vl_free(self->hog) ;
    self->hog = NULL ;
  }

  if (self->hogNorm) {
    vl_free(self->hogNorm) ;
    self->hogNorm = NULL ;
  }

  vl_free(self) ;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1ef79
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x1ef9d
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1efc1
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1efe5
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x1f009
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1f02d
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/hog.c
// Function: vl_hog_prepare_buffers
static void
vl_hog_prepare_buffers (VlHog * self, vl_size width, vl_size height, vl_size cellSize)
{
  vl_size hogWidth = (width + cellSize/2) / cellSize ;
  vl_size hogHeight = (height + cellSize/2) / cellSize ;

  assert(width > 3) ;
  assert(height > 3) ;
  assert(hogWidth > 0) ;
  assert(hogHeight > 0) ;

  if (self->hog &&
      self->hogWidth == hogWidth &&
      self->hogHeight == hogHeight) {
    /* a suitable buffer is already allocated */
    memset(self->hog, 0, sizeof(float) * hogWidth * hogHeight * self->numOrientations * 2) ;
    memset(self->hogNorm, 0, sizeof(float) * hogWidth * hogHeight) ;
    return ;
  }

  if (self->hog) {
    vl_free(self->hog) ;
    self->hog = NULL ;
  }

  if (self->hogNorm) {
    vl_free(self->hogNorm) ;
    self->hogNorm = NULL ;
  }

  self->hog = vl_calloc(hogWidth * hogHeight * self->numOrientations * 2, sizeof(float)) ;
  self->hogNorm = vl_calloc(hogWidth * hogHeight, sizeof(float)) ;
  self->hogWidth = hogWidth ;
  self->hogHeight = hogHeight ;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq %rcx
addq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x18(%rsp)
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x200d0
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x200d0
movq 0x30(%rsp), %rax
movq 0x60(%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0x200d0
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x10(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rax
imulq 0x10(%rax), %rdx
shlq %rdx
xorl %esi, %esi
callq 0x9480
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x10(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0x9480
jmp 0x20189
movq 0x30(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x200f7
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq 0x30(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x2011e
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq 0x30(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x10(%rsp), %rdi
imulq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
imulq 0x10(%rax), %rdi
shlq %rdi
movl $0x4, %esi
callq 0x9a70
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x10(%rsp), %rdi
imulq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x9a70
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x60(%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/homkermap.c
// Function: vl_homogeneouskernelmap_get_smooth_spectrum
VL_INLINE double
vl_homogeneouskernelmap_get_smooth_spectrum (VlHomogeneousKernelMap const * self, double omega)
{
  double kappa_hat = 0 ;
  double omegap ;
  double epsilon = 1e-2 ;
  double const omegaRange = 2.0 / (self->period * epsilon) ;
  double const domega = 2 * omegaRange / (2 * 1024.0 + 1) ;
  assert (self) ;
  switch (self->windowType) {
    case VlHomogeneousKernelMapWindowUniform:
      kappa_hat = vl_homogeneouskernelmap_get_spectrum(self, omega) ;
      break ;
    case VlHomogeneousKernelMapWindowRectangular:
      for (omegap = - omegaRange ; omegap <= omegaRange ; omegap += domega) {
        double win = sinc((self->period/2.0) * omegap) ;
        win *= (self->period/(2.0*VL_PI)) ;
        kappa_hat += win * vl_homogeneouskernelmap_get_spectrum(self, omegap + omega) ;
      }
      kappa_hat *= domega ;
      /* project on the postivie orthant (see PAMI) */
      kappa_hat = VL_MAX(kappa_hat, 0.0) ;
      break ;
    default:
      abort() ;
  }
  return kappa_hat ;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movabsq $0x3f847ae147ae147b, %rax # imm = 0x3F847AE147AE147B
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rax
movsd 0x20(%rax), %xmm1
movsd 0x30(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x36cbd(%rip), %xmm0    # 0x590e0
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
addsd %xmm0, %xmm0
movsd 0x37461(%rip), %xmm1    # 0x598a0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
testl %eax, %eax
je 0x22469
jmp 0x2245b
movl 0x14(%rsp), %eax
subl $0x1, %eax
je 0x22484
jmp 0x225a1
movq 0x50(%rsp), %rdi
movsd 0x48(%rsp), %xmm0
callq 0x22b90
movsd %xmm0, 0x40(%rsp)
jmp 0x225a6
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x2255c
movq 0x50(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd 0x36c11(%rip), %xmm1    # 0x590e0
divsd %xmm1, %xmm0
mulsd 0x38(%rsp), %xmm0
callq 0x22d10
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd 0x36d3a(%rip), %xmm1    # 0x59230
divsd %xmm1, %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movsd 0x38(%rsp), %xmm0
addsd 0x48(%rsp), %xmm0
callq 0x22b90
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x40(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x20(%rsp), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x224a7
movsd 0x20(%rsp), %xmm0
mulsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2258a
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x22594
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x22594
movsd (%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x225a6
callq 0x90b0
movsd 0x40(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/homkermap.c
// Function: vl_homogeneouskernelmap_get_spectrum
VL_INLINE double
vl_homogeneouskernelmap_get_spectrum (VlHomogeneousKernelMap const * self, double omega)
{
  assert (self) ;
  switch (self->kernelType) {
    case VlHomogeneousKernelIntersection:
      return (2.0 / VL_PI) / (1 + 4 * omega*omega) ;
    case VlHomogeneousKernelChi2:
      return 2.0 / (exp(VL_PI * omega) + exp(-VL_PI * omega)) ;
    case VlHomogeneousKernelJS:
      return (2.0 / log(4.0)) *
      2.0 / (exp(VL_PI * omega) + exp(-VL_PI * omega)) /
      (1 + 4 * omega*omega) ;
    default:
      abort() ;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
testl %eax, %eax
je 0x22bcd
jmp 0x22bb0
movl 0x1c(%rsp), %eax
subl $0x1, %eax
je 0x22c08
jmp 0x22bbb
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0x22c55
jmp 0x22cf4
movsd 0x36543(%rip), %xmm1    # 0x59118
mulsd 0x20(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
mulsd %xmm0, %xmm1
movsd 0x364eb(%rip), %xmm0    # 0x590d8
addsd %xmm0, %xmm1
movsd 0x36cb7(%rip), %xmm0    # 0x598b0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x22cf9
movsd 0x36be0(%rip), %xmm0    # 0x597f0
mulsd 0x20(%rsp), %xmm0
callq 0x9c10
movsd %xmm0, 0x10(%rsp)
movsd 0x36c7f(%rip), %xmm0    # 0x598a8
mulsd 0x20(%rsp), %xmm0
callq 0x9c10
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x3649a(%rip), %xmm0    # 0x590e0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x22cf9
movsd 0x364bb(%rip), %xmm0    # 0x59118
callq 0x94c0
movaps %xmm0, %xmm1
movsd 0x36473(%rip), %xmm0    # 0x590e0
divsd %xmm1, %xmm0
movsd 0x36467(%rip), %xmm1    # 0x590e0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x36b65(%rip), %xmm0    # 0x597f0
mulsd 0x20(%rsp), %xmm0
callq 0x9c10
movsd %xmm0, (%rsp)
movsd 0x36c05(%rip), %xmm0    # 0x598a8
mulsd 0x20(%rsp), %xmm0
callq 0x9c10
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x3644c(%rip), %xmm1    # 0x59118
mulsd 0x20(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
mulsd %xmm2, %xmm1
movsd 0x363f4(%rip), %xmm2    # 0x590d8
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x22cf9
callq 0x90b0
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/host.c
// Function: vl_x86cpu_info_init
void
_vl_x86cpu_info_init (VlX86CpuInfo *self)
{
  vl_int32 info [4] ;
  int max_func = 0 ;
  _vl_cpuid(info, 0) ;
  max_func = info[0] ;
  self->vendor.words[0] = info[1] ;
  self->vendor.words[1] = info[3] ;
  self->vendor.words[2] = info[2] ;

  if (max_func >= 1) {
    _vl_cpuid(info, 1) ;
    self->hasMMX   = info[3] & (1 << 23) ;
    self->hasSSE   = info[3] & (1 << 25) ;
    self->hasSSE2  = info[3] & (1 << 26) ;
    self->hasSSE3  = info[2] & (1 <<  0) ;
    self->hasSSE41 = info[2] & (1 << 19) ;
    self->hasSSE42 = info[2] & (1 << 20) ;
    self->hasAVX   = info[2] & (1 << 28) ;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x22e50
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x18(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x1, 0xc(%rsp)
jl 0x22e3d
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x22e50
movl 0x1c(%rsp), %ecx
andl $0x800000, %ecx         # imm = 0x800000
movq 0x20(%rsp), %rax
movl %ecx, 0x38(%rax)
movl 0x1c(%rsp), %ecx
andl $0x2000000, %ecx        # imm = 0x2000000
movq 0x20(%rsp), %rax
movl %ecx, 0x34(%rax)
movl 0x1c(%rsp), %ecx
andl $0x4000000, %ecx        # imm = 0x4000000
movq 0x20(%rsp), %rax
movl %ecx, 0x30(%rax)
movl 0x18(%rsp), %ecx
andl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x2c(%rax)
movl 0x18(%rsp), %ecx
andl $0x80000, %ecx          # imm = 0x80000
movq 0x20(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x18(%rsp), %ecx
andl $0x100000, %ecx         # imm = 0x100000
movq 0x20(%rsp), %rax
movl %ecx, 0x24(%rax)
movl 0x18(%rsp), %ecx
andl $0x10000000, %ecx       # imm = 0x10000000
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/host.c
// Function: vl_x86cpu_info_to_string_copy
char *
_vl_x86cpu_info_to_string_copy (VlX86CpuInfo const *self)
{
  char * string = 0 ;
  int length = 0 ;
  while (string == 0) {
    if (length > 0) {
      string = vl_malloc(sizeof(char) * length) ;
      if (string == NULL) break ;
    }
    length = snprintf(string, length, "%s%s%s%s%s%s%s%s",
                      self->vendor.string,
                      self->hasMMX   ? " MMX" : "",
                      self->hasSSE   ? " SSE" : "",
                      self->hasSSE2  ? " SSE2" : "",
                      self->hasSSE3  ? " SSE3" : "",
                      self->hasSSE41 ? " SSE41" : "",
                      self->hasSSE42 ? " SSE42" : "",
                      self->hasAVX   ? " AVX" : "") ;
    length += 1 ;
  }
  return string ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x23007
cmpl $0x0, 0x2c(%rsp)
jle 0x22ef3
movslq 0x2c(%rsp), %rdi
shlq $0x0, %rdi
callq 0x9660
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x22ef1
jmp 0x23007
jmp 0x22ef3
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
movq 0x38(%rsp), %rcx
movq 0x38(%rsp), %rax
movl 0x38(%rax), %edx
leaq 0x367b0(%rip), %r8      # 0x596c1
leaq 0x369b1(%rip), %rax     # 0x598c9
cmpl $0x0, %edx
cmovneq %rax, %r8
movq 0x38(%rsp), %rax
movl 0x34(%rax), %edx
leaq 0x36793(%rip), %r9      # 0x596c1
leaq 0x36999(%rip), %rax     # 0x598ce
cmpl $0x0, %edx
cmovneq %rax, %r9
movq 0x38(%rsp), %rax
movl 0x30(%rax), %edx
leaq 0x36776(%rip), %r14     # 0x596c1
leaq 0x369bb(%rip), %rax     # 0x5990d
cmpl $0x0, %edx
cmovneq %rax, %r14
movq 0x38(%rsp), %rax
movl 0x2c(%rax), %edx
leaq 0x36759(%rip), %rbx     # 0x596c1
leaq 0x36964(%rip), %rax     # 0x598d3
cmpl $0x0, %edx
cmovneq %rax, %rbx
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
leaq 0x3673c(%rip), %r11     # 0x596c1
leaq 0x3694d(%rip), %rax     # 0x598d9
cmpl $0x0, %edx
cmovneq %rax, %r11
movq 0x38(%rsp), %rax
movl 0x24(%rax), %edx
leaq 0x3671f(%rip), %r10     # 0x596c1
leaq 0x36937(%rip), %rax     # 0x598e0
cmpl $0x0, %edx
cmovneq %rax, %r10
movq 0x38(%rsp), %rax
movl 0x20(%rax), %ebp
leaq 0x36702(%rip), %rax     # 0x596c1
leaq 0x36921(%rip), %rdx     # 0x598e7
cmpl $0x0, %ebp
cmovneq %rdx, %rax
leaq 0x368e4(%rip), %rdx     # 0x598b8
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x9410
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x22ebe
movq 0x30(%rsp), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/ikmeans.c
// Function: vl_ikm_new
VlIKMFilt *
vl_ikm_new (int method)
{
  VlIKMFilt *f = vl_calloc (sizeof(VlIKMFilt), 1) ;
  f -> method = method ;
  f -> max_niters = 200 ;
  return f ;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x30, %edi
movl $0x1, %esi
callq 0x9a70
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq $0xc8, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/ikmeans.c
// Function: vl_ikm_delete
void
vl_ikm_delete (VlIKMFilt* f)
{
  if (f) {
    if (f->centers) vl_free(f->centers) ;
    if (f->inter_dist) vl_free(f->inter_dist) ;
    vl_free(f) ;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x23175
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x23154
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2316c
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/ikmeans.c
// Function: vl_ikm_train
int
vl_ikm_train (VlIKMFilt *f, vl_uint8 const *data, vl_size N)
{
  int err ;

  if (f-> verb) {
    VL_PRINTF ("ikm: training with %d data\n",  N) ;
    VL_PRINTF ("ikm: %d clusters\n",  f -> K) ;
  }

  switch (f -> method) {
  case VL_IKM_LLOYD : err = vl_ikm_train_lloyd (f, data, N) ; break ;
  case VL_IKM_ELKAN : err = vl_ikm_train_elkan (f, data, N) ; break ;
  default :
    abort() ;
  }
  return err ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x231d2
callq 0x91a0
movq %rax, %rcx
movq 0x10(%rsp), %rsi
leaq 0x3677a(%rip), %rdi     # 0x5992c
movb $0x0, %al
callq *%rcx
callq 0x91a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x3677a(%rip), %rdi     # 0x59948
movb $0x0, %al
callq *%rcx
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x231ef
jmp 0x231e4
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x23209
jmp 0x23223
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x23240
movl %eax, 0xc(%rsp)
jmp 0x23228
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x23630
movl %eax, 0xc(%rsp)
jmp 0x23228
callq 0x90b0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/ikmeans.c
// Function: vl_ikm_push
void
vl_ikm_push (VlIKMFilt *f, vl_uint32 *asgn, vl_uint8 const *data, vl_size N) {
  switch (f -> method) {
  case VL_IKM_LLOYD : vl_ikm_push_lloyd (f, asgn, data, N) ; break ;
  case VL_IKM_ELKAN : vl_ikm_push_elkan (f, asgn, data, N) ; break ;
  default :
    abort() ;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
testl %eax, %eax
je 0x249b5
jmp 0x249aa
movl 0x4(%rsp), %eax
subl $0x1, %eax
je 0x249d0
jmp 0x249eb
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x24a00
jmp 0x249f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x24a80
jmp 0x249f0
callq 0x90b0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/ikmeans.c
// Function: vl_ikm_push_one
vl_uint32
vl_ikm_push_one (vl_ikmacc_t const *centers,
		 vl_uint8 const *data,
		 vl_size M, vl_size K)
{
  vl_uindex i,k ;

  /* assign data to centers */
  vl_uindex best = (vl_uindex) -1 ;
  vl_ikmacc_t best_dist = 0 ;

  for(k = 0 ; k < K ; ++k) {
    vl_ikmacc_t dist = 0 ;

    /* compute distance with this center */
    for(i = 0 ; i < M ; ++i) {
      vl_ikmacc_t delta = (vl_ikmacc_t)data[i] - centers[k*M + i] ;
      dist += delta * delta ;
    }

    /* compare with current best */
    if (best == (vl_uindex) -1 || dist < best_dist) {
      best = k  ;
      best_dist = dist ;
    }
  }
  return (vl_uint32)best;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $-0x1, -0x38(%rsp)
movl $0x0, -0x3c(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x24cef
movl $0x0, -0x40(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x24cb6
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rsp), %rcx
movq -0x30(%rsp), %rdx
imulq -0x18(%rsp), %rdx
addq -0x28(%rsp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x44(%rsp)
movl -0x44(%rsp), %eax
imull -0x44(%rsp), %eax
addl -0x40(%rsp), %eax
movl %eax, -0x40(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x24c5f
cmpq $-0x1, -0x38(%rsp)
je 0x24cc8
movl -0x40(%rsp), %eax
cmpl -0x3c(%rsp), %eax
jge 0x24cda
movq -0x30(%rsp), %rax
movq %rax, -0x38(%rsp)
movl -0x40(%rsp), %eax
movl %eax, -0x3c(%rsp)
jmp 0x24cdc
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x24c3e
movq -0x38(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/imopv.c
// Function: vl_new_gaussian_fitler_f
static T*
VL_XCAT(_vl_new_gaussian_fitler_,SFX)(vl_size *size, double sigma)
{
  T* filter ;
  T mass = (T)1.0 ;
  vl_index i ;
  vl_size width = vl_ceil_d(sigma * 3.0) ;
  *size = 2 * width + 1 ;

  assert(size) ;

  filter = vl_malloc((*size) * sizeof(T)) ;
  filter[width] = 1.0 ;
  for (i = 1 ; i <= (signed)width ; ++i) {
    double x = (double)i / sigma ;
    double g = exp(-0.5 * x * x) ;
    mass += g + g ;
    filter[width-i] = g ;
    filter[width+i] = g ;
  }
  for (i = 0 ; i < (signed)(*size) ; ++i) {filter[i] /= mass ;}
  return filter ;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movss 0x328d9(%rip), %xmm0    # 0x59190
movss %xmm0, 0x2c(%rsp)
movsd 0x32803(%rip), %xmm0    # 0x590c8
mulsd 0x38(%rsp), %xmm0
callq 0x2a790
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
shlq %rcx
addq $0x1, %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
shlq $0x2, %rdi
callq 0x9660
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movss 0x3287f(%rip), %xmm0    # 0x59190
movss %xmm0, (%rax,%rcx,4)
movq $0x1, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jg 0x269da
cvtsi2sdq 0x20(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x32798(%rip), %xmm0    # 0x590e8
mulsd 0x10(%rsp), %xmm0
mulsd 0x10(%rsp), %xmm0
callq 0x9c10
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
addsd 0x8(%rsp), %xmm1
movss 0x2c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x2c(%rsp)
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
subq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movsd 0x8(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x20(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2691f
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x26a26
movss 0x2c(%rsp), %xmm1
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x269e3
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/imopv.c
// Function: vl_imintegral_f
VL_EXPORT void
VL_XCAT(vl_imintegral_, SFX)
(T * integral, vl_size integralStride,
 T const * image,
 vl_size imageWidth, vl_size imageHeight, vl_size imageStride)
{
  vl_uindex x, y ;
  T temp  = 0 ;

  if (imageHeight > 0) {
    for (x = 0 ; x < imageWidth ; ++ x) {
      temp += *image++ ;
      *integral++ = temp ;
    }
  }

  for (y = 1 ; y < imageHeight ; ++ y) {
    T * integralPrev ;
    integral += integralStride - imageWidth ;
    image += imageStride - imageWidth ;
    integralPrev = integral - integralStride ;

    temp = 0 ;
    for (x = 0 ; x < imageWidth ; ++ x) {
      temp += *image++ ;
      *integral++ = *integralPrev++ + temp ;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rsp)
cmpq $0x0, -0x28(%rsp)
jbe 0x27d12
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x27d10
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rsp)
movss (%rax), %xmm0
addss -0x44(%rsp), %xmm0
movss %xmm0, -0x44(%rsp)
movss -0x44(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rsp)
movss %xmm0, (%rax)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x27cb8
jmp 0x27d12
movq $0x1, -0x40(%rsp)
movq -0x40(%rsp), %rax
cmpq -0x28(%rsp), %rax
jae 0x27e07
movq -0x10(%rsp), %rax
subq -0x20(%rsp), %rax
shlq $0x2, %rax
addq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x30(%rsp), %rax
subq -0x20(%rsp), %rax
shlq $0x2, %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
xorl %ecx, %ecx
subq -0x10(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x27df2
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rsp)
movss (%rax), %xmm0
addss -0x44(%rsp), %xmm0
movss %xmm0, -0x44(%rsp)
movq -0x50(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x50(%rsp)
movss (%rax), %xmm0
addss -0x44(%rsp), %xmm0
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rsp)
movss %xmm0, (%rax)
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x27d85
jmp 0x27df4
movq -0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rsp)
jmp 0x27d1b
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdforest_new
VlKDForest *
vl_kdforest_new (vl_type dataType,
                 vl_size dimension, vl_size numTrees, VlVectorComparisonType distance)
{
  VlKDForest * self = vl_calloc (sizeof(VlKDForest), 1) ;

  assert(dataType == VL_TYPE_FLOAT || dataType == VL_TYPE_DOUBLE) ;
  assert(dimension >= 1) ;
  assert(numTrees >= 1) ;

  self -> rand = vl_get_rand () ;
  self -> dataType = dataType ;
  self -> numData = 0 ;
  self -> data = 0 ;
  self -> dimension = dimension ;
  self -> numTrees = numTrees ;
  self -> trees = 0 ;
  self -> thresholdingMethod = VL_KDTREE_MEDIAN ;
  self -> splitHeapSize = VL_MIN(numTrees, VL_KDTREE_SPLIT_HEAP_SIZE) ;
  self -> splitHeapNumNodes = 0 ;
  self -> distance = distance;
  self -> maxNumNodes = 0 ;
  self -> numSearchers = 0 ;
  self -> headSearcher = 0 ;

  switch (self->dataType) {
    case VL_TYPE_FLOAT:
      self -> distanceFunction = (void(*)(void))
      vl_get_vector_comparison_function_f (distance) ;
      break;
    case VL_TYPE_DOUBLE :
      self -> distanceFunction = (void(*)(void))
      vl_get_vector_comparison_function_d (distance) ;
      break ;
    default :
      abort() ;
  }

  return self ;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl $0xf8, %edi
movl $0x1, %esi
callq 0x9a70
movq %rax, 0x10(%rsp)
callq 0x9a20
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x34(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x48(%rax)
cmpq $0x5, 0x20(%rsp)
jae 0x2be79
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2be85
movl $0x5, %eax
movq %rax, 0x8(%rsp)
jmp 0x2be85
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0xc8(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0xd8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0xe8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0xf0(%rax)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x2bf00
jmp 0x2bef5
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x2bf17
jmp 0x2bf2e
movl 0x1c(%rsp), %edi
callq 0x9940
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x2bf33
movl 0x1c(%rsp), %edi
callq 0x9970
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x2bf33
callq 0x90b0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdforest_new_searcher
VlKDForestSearcher *
vl_kdforest_new_searcher (VlKDForest * kdforest)
{
  VlKDForestSearcher * self = vl_calloc(sizeof(VlKDForestSearcher), 1);
  if(kdforest->numSearchers == 0) {
    kdforest->headSearcher = self;
    self->previous = NULL;
    self->next = NULL;
  } else {
    VlKDForestSearcher * lastSearcher = kdforest->headSearcher;
    while (1) {
      if(lastSearcher->next) {
        lastSearcher = lastSearcher->next;
      } else {
        lastSearcher->next = self;
        self->previous = lastSearcher;
        self->next = NULL;
        break;
      }
    }
  }

  kdforest->numSearchers++;

  self->forest = kdforest;
  self->searchHeapArray = vl_malloc (sizeof(VlKDForestSearchState) * kdforest->maxNumNodes) ;
  self->searchIdBook = vl_calloc (sizeof(vl_uindex), kdforest->numData) ;
  return self ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x50, %edi
movl $0x1, %esi
callq 0x9a70
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0xe8(%rax)
jne 0x2bf98
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xf0(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x2bfea
movq 0x10(%rsp), %rax
movq 0xf0(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x2bfbf
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x2bfe6
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x2bfe8
jmp 0x2bfa8
jmp 0x2bfea
movq 0x10(%rsp), %rax
movq 0xe8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xe8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
imulq $0x18, 0xd8(%rax), %rdi
callq 0x9660
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movl $0x8, %edi
callq 0x9a70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdforestsearcher_delete
void
vl_kdforestsearcher_delete (VlKDForestSearcher * self)
{
  if (self->previous && self->next) {
    self->previous->next = self->next;
    self->next->previous = self->previous;
  } else if (self->previous && !self->next) {
    self->previous->next = NULL;
  } else if (!self->previous && self->next) {
    self->next->previous = NULL;
    self->forest->headSearcher = self->next;
  } else {
    self->forest->headSearcher = NULL;
  }
  self->forest->numSearchers -- ;
  vl_free(self->searchHeapArray) ;
  vl_free(self->searchIdBook) ;
  vl_free(self) ;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2c0a1
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x2c0a1
movq (%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x2c11a
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2c0c7
movq (%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2c0c7
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, (%rax)
jmp 0x2c118
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2c103
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x2c103
movq (%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0xf0(%rax)
jmp 0x2c116
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0xf0(%rax)
jmp 0x2c118
jmp 0x2c11a
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq 0xe8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0xe8(%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdforest_get_searcher
VlKDForestSearcher *
vl_kdforest_get_searcher (VlKDForest const * self, vl_uindex pos)
{
  VlKDForestSearcher * lastSearcher = self->headSearcher ;
  vl_uindex i ;

  for(i = 0; (i < pos) & (lastSearcher != NULL) ; ++i) {
    lastSearcher = lastSearcher->next ;
  }
  return lastSearcher ;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0xf0(%rax), %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cmpq $0x0, -0x18(%rsp)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2c1c9
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x2c184
movq -0x18(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdforest_delete
void
vl_kdforest_delete (VlKDForest * self)
{
  vl_uindex ti ;
  VlKDForestSearcher * searcher ;

  while ((searcher = vl_kdforest_get_searcher(self, 0))) {
    vl_kdforestsearcher_delete(searcher) ;
  }

  if (self->trees) {
    for (ti = 0 ; ti < self->numTrees ; ++ ti) {
      if (self->trees[ti]) {
        if (self->trees[ti]->nodes) vl_free (self->trees[ti]->nodes) ;
        if (self->trees[ti]->dataIndex) vl_free (self->trees[ti]->dataIndex) ;
        vl_free (self->trees[ti]) ;
      }
    }
    vl_free (self->trees) ;
  }
  vl_free (self) ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x96b0
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2c1fc
movq (%rsp), %rdi
callq 0x91f0
jmp 0x2c1d9
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2c2de
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x2c2d0
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x2c2bb
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
je 0x2c270
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x18(%rax)
je 0x2c2a4
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9620
jmp 0x2c2bd
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2c215
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rdi
callq 0x9620
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdtree_node_new
static vl_uindex
vl_kdtree_node_new (VlKDTree * tree, vl_uindex parentIndex)
{
  VlKDTreeNode * node = NULL ;
  vl_uindex nodeIndex = tree->numUsedNodes ;
  tree -> numUsedNodes += 1 ;

  assert (tree->numUsedNodes <= tree->numAllocatedNodes) ;

  node = tree->nodes + nodeIndex ;
  node -> parent = parentIndex ;
  node -> lowerChild = 0 ;
  node -> upperChild = 0 ;
  node -> splitDimension = 0 ;
  node -> splitThreshold = 0 ;
  return nodeIndex ;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rax
imulq $0x38, -0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rsp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x20(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdtree_calc_bounds_recursively
static void
vl_kdtree_calc_bounds_recursively (VlKDTree * tree,
                                   vl_uindex nodeIndex, double * searchBounds)
{
  VlKDTreeNode * node = tree->nodes + nodeIndex ;
  vl_uindex i = node->splitDimension ;
  double t = node->splitThreshold ;

  node->lowerBound = searchBounds [2 * i + 0] ;
  node->upperBound = searchBounds [2 * i + 1] ;

  //VL_PRINT("%f %f\n",node->lowerBound,node->upperBound);

  if (node->lowerChild > 0) {
    searchBounds [2 * i + 1] = t ;
    vl_kdtree_calc_bounds_recursively (tree, node->lowerChild, searchBounds) ;
    searchBounds [2 * i + 1] = node->upperBound ;
  }
  if (node->upperChild > 0) {
    searchBounds [2 * i + 0] = t ;
    vl_kdtree_calc_bounds_recursively (tree, node->upperChild, searchBounds) ;
    searchBounds [2 * i + 0] = node->lowerBound ;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
imulq $0x38, 0x28(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movsd 0x8(%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x2d0d9
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x2d000
movq 0x18(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movsd %xmm0, 0x8(%rax,%rcx,8)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jle 0x2d131
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0x2d000
movq 0x18(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdforest_query
vl_size
vl_kdforest_query (VlKDForest * self,
                   VlKDForestNeighbor * neighbors,
                   vl_size numNeighbors,
                   void const * query)
{
  VlKDForestSearcher * searcher = vl_kdforest_get_searcher(self, 0) ;
  if (searcher == NULL) {
    searcher = vl_kdforest_new_searcher(self) ;
  }
  return vl_kdforestsearcher_query(searcher,
                                   neighbors,
                                   numNeighbors,
                                   query) ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x96b0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2d8ef
movq 0x20(%rsp), %rdi
callq 0x9130
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x9320
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/heap-def.h
// Function: vl_kdforest_search_heap_pop
VL_INLINE vl_uindex
VL_HEAP_pop
(VL_HEAP_array array, vl_size *heapSize)
{
  assert (*heapSize) ;

  *heapSize -= 1 ;

  VL_HEAP_swap (array, 0, *heapSize) ;

  if (*heapSize > 1) {
    VL_HEAP_up (array, *heapSize, 0) ;
  }

  return *heapSize ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x2e770
movq 0x8(%rsp), %rax
cmpq $0x1, (%rax)
jbe 0x2dc14
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2e810
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/kdtree.c
// Function: vl_kdtree_compare_index_entries
VL_INLINE int
vl_kdtree_compare_index_entries (void const * a,
                                 void const * b)
{
  double delta =
    ((VlKDTreeDataIndexEntry const*)a) -> value -
    ((VlKDTreeDataIndexEntry const*)b) -> value ;
  if (delta < 0) return -1 ;
  if (delta > 0) return +1 ;
  return 0 ;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rsp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rsp), %xmm0
jbe 0x2e119
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2e13a
movsd -0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2e132
movl $0x1, -0x4(%rsp)
jmp 0x2e13a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/heap-def.h
// Function: vl_kdtree_split_heap_down
VL_INLINE void
VL_HEAP_down
(VL_HEAP_array array, vl_uindex index)
{
  vl_uindex parentIndex ;

  if (index == 0) return  ;

  parentIndex = vl_heap_parent (index) ;

  if (VL_HEAP_cmp (array, index, parentIndex) < 0) {
    VL_HEAP_swap (array, index, parentIndex) ;
    VL_HEAP_down (array, parentIndex) ;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2e158
jmp 0x2e1b5
movq 0x8(%rsp), %rdi
callq 0x2e1c0
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm1
movq 0x10(%rsp), %rax
imulq $0x18, (%rsp), %rcx
addq %rcx, %rax
subsd 0x10(%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2e1b5
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2e1f0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x2e140
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/heap-def.h
// Function: vl_kdtree_split_heap_up
VL_INLINE void
VL_HEAP_up
(VL_HEAP_array array, vl_size heapSize, vl_uindex index)
{
  vl_uindex leftIndex  = vl_heap_left_child (index) ;
  vl_uindex rightIndex = vl_heap_right_child (index) ;

  /* no childer: stop */
  if (leftIndex >= heapSize) return ;

  /* only left childer: easy */
  if (rightIndex >= heapSize) {
    if (VL_HEAP_cmp (array, index, leftIndex) > 0) {
      VL_HEAP_swap (array, index, leftIndex) ;
    }
    return ;
  }

  /* both childern */
  {
    if (VL_HEAP_cmp (array, leftIndex, rightIndex) < 0) {
      /* swap with left */
      if (VL_HEAP_cmp (array, index, leftIndex) > 0) {
        VL_HEAP_swap (array, index, leftIndex) ;
        VL_HEAP_up (array, heapSize, leftIndex) ;
      }
    } else {
      /* swap with right */
      if (VL_HEAP_cmp (array, index, rightIndex) > 0) {
        VL_HEAP_swap (array, index, rightIndex) ;
        VL_HEAP_up (array, heapSize, rightIndex) ;
      }
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2e410
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2e430
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x2e2d1
jmp 0x2e401
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x2e324
movq 0x20(%rsp), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq 0x20(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
subsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2e31f
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2e1f0
jmp 0x2e401
movq 0x20(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm1
movq 0x20(%rsp), %rax
imulq $0x18, (%rsp), %rcx
addq %rcx, %rax
subsd 0x10(%rax), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2e3ab
movq 0x20(%rsp), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq 0x20(%rsp), %rax
imulq $0x18, 0x8(%rsp), %rcx
addq %rcx, %rax
subsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2e3a9
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2e1f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2e290
jmp 0x2e401
movq 0x20(%rsp), %rax
imulq $0x18, 0x10(%rsp), %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq 0x20(%rsp), %rax
imulq $0x18, (%rsp), %rcx
addq %rcx, %rax
subsd 0x10(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2e3ff
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2e1f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2e290
jmp 0x2e401
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)