LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/aib.c
// Function: vl_aib_min_beta
void vl_aib_min_beta
(VlAIB * aib, vl_uint * besti, vl_uint * bestj, double * minbeta)
{
    vl_uint i;
    *minbeta = aib->beta[0];
    *besti   = 0;
    *bestj   = aib->bidx[0];

    for(i=0; i<aib->nentries; i++)
    {
        if(aib->beta[i] < *minbeta)
        {
            *minbeta = aib->beta[i];
            *besti = i;
            *bestj = aib->bidx[i];
        }
    }
}

// Assembly:
movq 0x10(%rdi), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rcx)
movl $0x0, (%rsi)
movq 0x18(%rdi), %r8
movl (%r8), %r9d
movl %r9d, (%rdx)
movl 0x8(%rdi), %r10d
testl %r10d, %r10d
je 0x9da8
xorl %r9d, %r9d
movsd (%rax,%r9,8), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9d9d
movsd %xmm1, (%rcx)
movl %r9d, (%rsi)
movl (%r8,%r9,4), %r10d
movl %r10d, (%rdx)
movl 0x8(%rdi), %r10d
movapd %xmm1, %xmm0
incq %r9
movl %r10d, %r11d
cmpq %r11, %r9
jb 0x9d7b
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/aib.c
// Function: vl_aib_calculate_information
void vl_aib_calculate_information(VlAIB * aib, double * I, double * H)
{
    vl_uint r, c;
    *H = 0;
    *I = 0;

    /*
     * H(x)   = - sum_x p(x)    \ log p(x)
     * I(x,c) =   sum_xc p(x,c) \ log (p(x,c) / p(x)p(c))
     */

    /* for each entry */
    for(r = 0 ; r< aib->nentries ; r++) {

      if (aib->Px[r] == 0) continue ;
      *H += -log(aib->Px[r]) * aib->Px[r] ;

      for(c=0; c<aib->nlabels; c++) {
        if (aib->Pcx[r*aib->nlabels+c] == 0) continue;
        *I += aib->Pcx[r*aib->nlabels+c] *
          log (aib->Pcx[r*aib->nlabels+c] / (aib->Px[r]*aib->Pc[c])) ;
      }
    }
}

// Assembly:
xorl %eax, %eax
movq %rax, (%rdx)
movq %rax, (%rsi)
cmpl $0x0, 0x8(%rdi)
je 0xa1e8
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorpd %xmm1, %xmm1
movq 0x38(%r15), %rax
movsd (%rax,%r12,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0xa142
jnp 0xa1cb
callq 0x9430
movq 0x38(%r15), %rax
movsd (%rbx), %xmm1
mulsd (%rax,%r12,8), %xmm0
subsd %xmm0, %xmm1
movsd %xmm1, (%rbx)
xorpd %xmm1, %xmm1
movl 0x4c(%r15), %eax
testl %eax, %eax
je 0xa1cb
xorl %r13d, %r13d
movq 0x30(%r15), %rcx
movl %r12d, %edx
imull %eax, %edx
addl %r13d, %edx
movsd (%rcx,%rdx,8), %xmm0
ucomisd %xmm1, %xmm0
jne 0xa186
jnp 0xa1c1
movq 0x38(%r15), %rax
movq 0x40(%r15), %rcx
movsd (%rax,%r12,8), %xmm1
mulsd (%rcx,%r13,8), %xmm1
movsd %xmm0, 0x8(%rsp)
divsd %xmm1, %xmm0
callq 0x9430
xorpd %xmm1, %xmm1
mulsd 0x8(%rsp), %xmm0
addsd (%r14), %xmm0
movsd %xmm0, (%r14)
movl 0x4c(%r15), %eax
incq %r13
movl %eax, %ecx
cmpq %rcx, %r13
jb 0xa16c
incq %r12
movl 0x8(%r15), %eax
cmpq %rax, %r12
jb 0xa12c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/aib.c
// Function: vl_aib_delete
void
vl_aib_delete (VlAIB * aib)
{
  if (aib) {
    if (aib-> nodes)   vl_free (aib-> nodes);
    if (aib-> beta)    vl_free (aib-> beta);
    if (aib-> bidx)    vl_free (aib-> bidx);
    if (aib-> which)   vl_free (aib-> which);
    if (aib-> Px)      vl_free (aib-> Px);
    if (aib-> Pc)      vl_free (aib-> Pc);
    if (aib-> parents) vl_free (aib-> parents);
    if (aib-> costs)   vl_free (aib-> costs);

    vl_free (aib) ;
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa57c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa511
callq 0x9580
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa51f
callq 0x9580
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa52d
callq 0x9580
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xa53b
callq 0x9580
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xa549
callq 0x9580
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0xa557
callq 0x9580
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xa565
callq 0x9580
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0xa573
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/array.c
// Function: vl_array_init
VL_EXPORT VlArray *
vl_array_init (VlArray* self, vl_type type,
               vl_size numDimensions, vl_size const * dimensions)
{
  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
  self->type = type ;
  self->numDimensions = numDimensions ;
  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
  self->data = vl_malloc(vl_get_type_size(type) * vl_array_get_num_elements (self)) ;
  self->isEnvelope = VL_FALSE ;
  self->isSparse = VL_FALSE ;
  return self ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, (%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x18(%rdi), %r15
leaq (,%rdx,8), %rdx
movq %r15, %rdi
movq %rcx, %rsi
callq 0x95a0
decl %ebp
cmpl $0xa, %ebp
jae 0xa829
movl %ebp, %eax
leaq 0x2789e(%rip), %rcx     # 0x32080
movq (%rcx,%rax,8), %rax
testq %r14, %r14
je 0xa801
movl $0x1, %edi
xorl %ecx, %ecx
imulq (%r15,%rcx,8), %rdi
incq %rcx
cmpq %rcx, %r14
jne 0xa7f2
jmp 0xa803
xorl %edi, %edi
imulq %rax, %rdi
callq 0x95b0
movq %rax, 0x98(%rbx)
movq $0x0, 0x4(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/array.c
// Function: vl_array_dealloc
VL_EXPORT void
vl_array_dealloc (VlArray * self)
{
  if (! self->isEnvelope) {
    if (self->data) {
      vl_free(self->data) ;
      self->data = NULL ;
    }
  }
}

// Assembly:
cmpl $0x0, 0x4(%rdi)
je 0xa8c0
retq
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
testq %rdi, %rdi
je 0xa8e0
callq 0x9580
movq $0x0, 0x98(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/covdet.c
// Function: vl_resize_buffer
static int
_vl_resize_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
  void * newBuffer ;
  if (*buffer == NULL) {
    *buffer = vl_malloc(targetSize) ;
    if (*buffer) {
      *bufferSize = targetSize ;
      return VL_ERR_OK ;
    } else {
      *bufferSize = 0 ;
      return VL_ERR_ALLOC ;
    }
  }
  newBuffer = vl_realloc(*buffer, targetSize) ;
  if (newBuffer) {
    *buffer = newBuffer ;
    *bufferSize = targetSize ;
    return VL_ERR_OK ;
  } else {
    return VL_ERR_ALLOC ;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xb098
movq %rbx, %rsi
callq 0x93e0
testq %rax, %rax
je 0xb0b9
movq %rax, (%r15)
xorl %eax, %eax
jmp 0xb0b4
movq %rbx, %rdi
callq 0x95b0
movq %rax, %rcx
movq %rax, (%r15)
xorl %eax, %eax
testq %rcx, %rcx
sete %al
cmoveq %rcx, %rbx
addl %eax, %eax
movq %rbx, (%r14)
jmp 0xb0be
movl $0x2, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_reset
void
vl_covdet_reset (VlCovDet * self)
{
  if (self->features) {
    vl_free(self->features) ;
    self->features = NULL ;
  }
  if (self->css) {
    vl_scalespace_delete(self->css) ;
    self->css = NULL ;
  }
  if (self->gss) {
    vl_scalespace_delete(self->gss) ;
    self->gss = NULL ;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xbdf7
callq 0x9580
movq $0x0, 0x50(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xbe0d
callq 0x9820
movq $0x0, 0x8(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbe21
callq 0x9820
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_append_feature
int
vl_covdet_append_feature (VlCovDet * self, VlCovDetFeature const * feature)
{
  vl_size requiredSize ;
  assert(self) ;
  assert(feature) ;
  self->numFeatures ++ ;
  requiredSize = self->numFeatures * sizeof(VlCovDetFeature) ;
  if (requiredSize > self->numFeatureBufferSize) {
    int err = _vl_resize_buffer((void**)&self->features, &self->numFeatureBufferSize,
                                (self->numFeatures + 1000) * sizeof(VlCovDetFeature)) ;
    if (err) {
      self->numFeatures -- ;
      return err ;
    }
  }
  self->features[self->numFeatures - 1] = *feature ;
  return VL_ERR_OK ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x58(%rdi)
leaq 0x8(,%rax,8), %rdx
leaq (%rdx,%rdx,4), %rdx
cmpq 0x60(%rdi), %rdx
jbe 0xbe95
leaq 0x60(%r14), %rsi
leaq 0x50(%r14), %rdi
leaq (%rax,%rax,4), %rax
leaq 0x9c68(,%rax,8), %rdx
callq 0xb06e
movq 0x58(%r14), %rcx
testl %eax, %eax
je 0xbe95
decq %rcx
movq %rcx, 0x58(%r14)
jmp 0xbeb9
movq 0x50(%r14), %rax
leaq (%rcx,%rcx,4), %rcx
movq 0x20(%rbx), %rdx
movq %rdx, -0x8(%rax,%rcx,8)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, -0x18(%rax,%rcx,8)
movups %xmm0, -0x28(%rax,%rcx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_extract_affine_shape
void
vl_covdet_extract_affine_shape (VlCovDet * self)
{
  vl_index i, j = 0 ;
  vl_size numFeatures = vl_covdet_get_num_features(self) ;
  VlCovDetFeature * feature = vl_covdet_get_features(self);
  for (i = 0 ; i < (signed)numFeatures ; ++i) {
    int status ;
    VlFrameOrientedEllipse adapted ;
    status = vl_covdet_extract_affine_shape_for_frame(self, &adapted, feature[i].frame) ;
    if (status == VL_ERR_OK) {
      feature[j] = feature[i] ;
      feature[j].frame = adapted ;
      ++ j ;
    }
  }
  self->numFeatures = j ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movslq 0x58(%rdi), %r12
testq %r12, %r12
jle 0xe2dd
movq 0x50(%rbx), %r13
xorl %r15d, %r15d
leaq 0x40(%rsp), %r14
movq %r13, %rbp
movq 0x10(%rbp), %rax
movq %rax, 0x30(%rsp)
movups (%rbp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9750
testl %eax, %eax
jne 0xe2d2
leaq (%r15,%r15,4), %rax
movq 0x20(%rbp), %rcx
movq %rcx, 0x20(%r13,%rax,8)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x10(%r13,%rax,8)
movups %xmm0, (%r13,%rax,8)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%r13,%rax,8)
movq 0x50(%rsp), %rcx
movq %rcx, 0x10(%r13,%rax,8)
incq %r15
addq $0x28, %rbp
decq %r12
jne 0xe265
jmp 0xe2e0
xorl %r15d, %r15d
movq %r15, 0x58(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_check_frame_inside
vl_bool
_vl_covdet_check_frame_inside (VlCovDet * self, VlFrameOrientedEllipse frame, double margin)
{
  double extent = margin ;
  double A [2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
  double T[2] = {frame.x, frame.y} ;
  double x0 = +VL_INFINITY_D ;
  double x1 = -VL_INFINITY_D ;
  double y0 = +VL_INFINITY_D ;
  double y1 = -VL_INFINITY_D ;
  double boxx [4] = {extent, extent, -extent, -extent} ;
  double boxy [4] = {-extent, extent, extent, -extent} ;
  VlScaleSpaceGeometry geom = vl_scalespace_get_geometry(self->gss) ;
  int i ;
  for (i = 0 ; i < 4 ; ++i) {
    double x = A[0] * boxx[i] + A[2] * boxy[i] + T[0] ;
    double y = A[1] * boxx[i] + A[3] * boxy[i] + T[1] ;
    x0 = VL_MIN(x0, x) ;
    x1 = VL_MAX(x1, x) ;
    y0 = VL_MIN(y0, y) ;
    y1 = VL_MAX(y1, y) ;
  }

  return
  0 <= x0 && x1 <= geom.width-1 &&
  0 <= y0 && y1 <= geom.height-1 ;
}

// Assembly:
subq $0xb8, %rsp
movups 0xc8(%rsp), %xmm1
movss 0xd0(%rsp), %xmm2
movlhps %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
shufps $0xe2, %xmm1, %xmm2     # xmm2 = xmm2[2,0],xmm1[2,3]
cvtps2pd %xmm2, %xmm1
movaps %xmm1, 0x40(%rsp)
movaps 0xc0(%rsp), %xmm1
movss 0xd4(%rsp), %xmm2
shufps $0xf4, %xmm1, %xmm2     # xmm2 = xmm2[0,1],xmm1[3,3]
shufps $0xf2, %xmm1, %xmm2     # xmm2 = xmm2[2,0],xmm1[3,3]
cvtps2pd %xmm2, %xmm1
movaps %xmm1, 0x30(%rsp)
cvtps2pd 0xc0(%rsp), %xmm1
movaps %xmm1, 0x20(%rsp)
movq %xmm0, 0x50(%rsp)
movq %xmm0, 0x58(%rsp)
movdqa 0x233b4(%rip), %xmm1    # 0x320d0
pxor %xmm0, %xmm1
pshufd $0x44, %xmm1, %xmm2     # xmm2 = xmm1[0,1,0,1]
movdqa %xmm2, 0x60(%rsp)
movq %xmm1, (%rsp)
movq %xmm0, 0x8(%rsp)
movq %xmm0, 0x10(%rsp)
movq %xmm1, 0x18(%rsp)
movq (%rdi), %rsi
leaq 0x70(%rsp), %rdi
callq 0x98c0
movapd 0x20(%rsp), %xmm6
movapd 0x30(%rsp), %xmm5
movapd 0x40(%rsp), %xmm4
movapd 0x23437(%rip), %xmm0    # 0x321a0
movapd 0x2343f(%rip), %xmm1    # 0x321b0
xorl %eax, %eax
movsd (%rsp,%rax,8), %xmm2
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
mulpd %xmm5, %xmm2
movsd 0x50(%rsp,%rax,8), %xmm3
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
addpd %xmm2, %xmm3
addpd %xmm6, %xmm3
minpd %xmm3, %xmm1
maxpd %xmm3, %xmm0
incq %rax
cmpq $0x4, %rax
jne 0xed73
xorl %eax, %eax
pxor %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jb 0xee26
movq 0x70(%rsp), %rcx
decq %rcx
movq %rcx, %xmm2
punpckldq 0x233b8(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x233c0(%rip), %xmm2    # 0x32190
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
ucomisd %xmm0, %xmm3
jb 0xee26
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jb 0xee26
movq 0x78(%rsp), %rax
decq %rax
movq %rax, %xmm1
punpckldq 0x2337b(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x23383(%rip), %xmm1    # 0x32190
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
xorl %eax, %eax
ucomisd %xmm0, %xmm2
setae %al
addq $0xb8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_drop_features_outside
void
vl_covdet_drop_features_outside (VlCovDet * self, double margin)
{
  vl_index i, j = 0 ;
  vl_size numFeatures = vl_covdet_get_num_features(self) ;
  for (i = 0 ; i < (signed)numFeatures ; ++i) {
    vl_bool inside =
    _vl_covdet_check_frame_inside (self, self->features[i].frame, margin) ;
    if (inside) {
      self->features[j] = self->features[i] ;
      ++j ;
    }
  }
  self->numFeatures = j ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
movslq 0x58(%rdi), %r14
testq %r14, %r14
jle 0xeec2
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0x50(%rbx), %rax
movq 0x10(%rax,%r12), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax,%r12), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
callq 0xecb3
testl %eax, %eax
je 0xeeb7
movq 0x50(%rbx), %rax
leaq (%r15,%r15,4), %rcx
movq 0x20(%rax,%r12), %rdx
movq %rdx, 0x20(%rax,%rcx,8)
movups (%rax,%r12), %xmm0
movups 0x10(%rax,%r12), %xmm1
movups %xmm1, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
incq %r15
addq $0x28, %r12
decq %r14
jne 0xee51
jmp 0xeec5
xorl %r15d, %r15d
movq %r15, 0x58(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_new_kernel
float *
_vl_dsift_new_kernel (int binSize, int numBins, int binIndex, double windowSize)
{
  int filtLen = 2 * binSize - 1 ;
  float * ker = vl_malloc (sizeof(float) * filtLen) ;
  float * kerIter = ker ;
  float delta = binSize * (binIndex - 0.5F * (numBins - 1)) ;
  /*
  float sigma = 0.5F * ((numBins - 1) * binSize + 1) ;
  float sigma = 0.5F * ((numBins) * binSize) ;
  */
  float sigma = (float) binSize * (float) windowSize ;
  int x ;

  for (x = - binSize + 1 ; x <= + binSize - 1 ; ++ x) {
    float z = (x - delta) / sigma ;
    *kerIter++ = (1.0F - fabsf(x) / binSize) *
      ((binIndex >= 0) ? expf(- 0.5F * z*z) : 1.0F) ;
  }
  return ker ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x10(%rsp)
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r15d
leal (%r15,%r15), %eax
cltq
leaq -0x4(,%rax,4), %rdi
callq 0x95b0
movq %rax, %r14
movl $0x1, %eax
subl %r15d, %eax
cmpl %r15d, %eax
jge 0xf05d
cvtsi2ss %r15d, %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
decl %ebp
cvtsi2ss %ebp, %xmm2
mulss 0x233a8(%rip), %xmm2    # 0x32358
addss %xmm0, %xmm2
mulss %xmm1, %xmm2
movss %xmm2, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsd2ss 0x10(%rsp), %xmm0
movss %xmm1, 0xc(%rsp)
mulss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
leal -0x2(,%r15,2), %r15d
incq %r15
movl %eax, %r12d
xorl %r13d, %r13d
movss 0x2336c(%rip), %xmm2    # 0x3235c
leal (%r12,%r13), %eax
xorps %xmm3, %xmm3
cvtsi2ss %eax, %xmm3
movaps %xmm2, %xmm0
testl %ebx, %ebx
js 0xf037
movaps %xmm3, %xmm1
subss 0x8(%rsp), %xmm1
divss 0x4(%rsp), %xmm1
movaps %xmm1, %xmm0
mulss 0x2333c(%rip), %xmm0    # 0x32358
mulss %xmm1, %xmm0
movaps %xmm3, 0x10(%rsp)
callq 0x91a0
movaps 0x10(%rsp), %xmm3
movss 0x23325(%rip), %xmm2    # 0x3235c
andps 0x23132(%rip), %xmm3    # 0x32170
divss 0xc(%rsp), %xmm3
movaps %xmm2, %xmm1
subss %xmm3, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r14,%r13,4)
incq %r13
cmpl %r13d, %r15d
jne 0xeff0
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_new
VL_EXPORT VlDsiftFilter *
vl_dsift_new (int imWidth, int imHeight)
{
  VlDsiftFilter * self = vl_malloc (sizeof(VlDsiftFilter)) ;
  self->imWidth  = imWidth ;
  self->imHeight = imHeight ;

  self->stepX = 5 ;
  self->stepY = 5 ;

  self->boundMinX = 0 ;
  self->boundMinY = 0 ;
  self->boundMaxX = imWidth - 1 ;
  self->boundMaxY = imHeight - 1 ;

  self->geom.numBinX = 4 ;
  self->geom.numBinY = 4 ;
  self->geom.numBinT = 8 ;
  self->geom.binSizeX = 5 ;
  self->geom.binSizeY = 5 ;

  self->useFlatWindow = VL_FALSE ;
  self->windowSize = 2.0 ;

  self->convTmp1 = vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
  self->convTmp2 = vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;

  self->numBinAlloc = 0 ;
  self->numFrameAlloc = 0 ;
  self->numGradAlloc = 0 ;

  self->descrSize = 0 ;
  self->numFrames = 0 ;
  self->grads = NULL ;
  self->frames = NULL ;
  self->descrs = NULL ;

  _vl_dsift_update_buffers(self) ;
  return self ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %r15d
movl $0x80, %edi
callq 0x95b0
movq %rax, %rbx
movl %r15d, (%rax)
movl %r14d, 0x4(%rax)
movsd 0x23290(%rip), %xmm0    # 0x32390
movups %xmm0, 0x8(%rax)
leal -0x1(%r15), %eax
movl %eax, 0x18(%rbx)
leal -0x1(%r14), %eax
movl %eax, 0x1c(%rbx)
movaps 0x23287(%rip), %xmm0    # 0x323a0
movups %xmm0, 0x20(%rbx)
movq $0x5, 0x30(%rbx)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0x38(%rbx)
movslq %r15d, %rax
movslq %r14d, %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x95b0
movq %rax, 0x70(%rbx)
movslq (%rbx), %rax
movslq 0x4(%rbx), %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x95b0
movq %rax, 0x78(%rbx)
movq $0x0, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movl $0x0, 0x60(%rbx)
movq %rbx, %rdi
callq 0x9790
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_delete
VL_EXPORT void
vl_dsift_delete (VlDsiftFilter * self)
{
  _vl_dsift_free_buffers (self) ;
  if (self->convTmp2) vl_free (self->convTmp2) ;
  if (self->convTmp1) vl_free (self->convTmp1) ;
  vl_free (self) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xf1f1
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xf1da
callq 0x9580
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xf1e8
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_free_buffers
static void
_vl_dsift_free_buffers (VlDsiftFilter* self)
{
  if (self->frames) {
    vl_free(self->frames) ;
    self->frames = NULL ;
  }
  if (self->descrs) {
    vl_free(self->descrs) ;
    self->descrs = NULL ;
  }
  if (self->grads) {
    int t ;
    for (t = 0 ; t < self->numGradAlloc ; ++t)
      if (self->grads[t]) vl_free(self->grads[t]) ;
    vl_free(self->grads) ;
    self->grads = NULL ;
  }
  self->numFrameAlloc = 0 ;
  self->numBinAlloc = 0 ;
  self->numGradAlloc = 0 ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0xf20e
callq 0x9580
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf224
callq 0x9580
movq $0x0, 0x50(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xf268
movl 0x60(%rbx), %eax
testl %eax, %eax
jle 0xf25b
xorl %r14d, %r14d
movq 0x68(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0xf24c
callq 0x9580
movl 0x60(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0xf237
movq 0x68(%rbx), %rdi
callq 0x9580
movq $0x0, 0x68(%rbx)
movq $0x0, 0x58(%rbx)
movl $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_get_bin_window_mean
static float
_vl_dsift_get_bin_window_mean
(int binSize, int numBins, int binIndex, double windowSize)
{
  float delta = binSize * (binIndex - 0.5F * (numBins - 1)) ;
  /*float sigma = 0.5F * ((numBins - 1) * binSize + 1) ;*/
  float sigma = (float) binSize * (float) windowSize ;
  int x ;

  float acc = 0.0 ;
  for (x = - binSize + 1 ; x <= + binSize - 1 ; ++ x) {
    float z = (x - delta) / sigma ;
    acc += ((binIndex >= 0) ? expf(- 0.5F * z*z) : 1.0F) ;
  }
  return acc /= (2 * binSize - 1) ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movl $0x1, %r14d
subl %edi, %r14d
xorps %xmm1, %xmm1
cmpl %edi, %r14d
jge 0xff07
movl %edx, %ebp
xorps %xmm1, %xmm1
cvtsi2ss %ebx, %xmm1
cvtsi2ss %edx, %xmm2
decl %esi
cvtsi2ss %esi, %xmm3
mulss 0x224c4(%rip), %xmm3    # 0x32358
addss %xmm2, %xmm3
mulss %xmm1, %xmm3
movss %xmm3, 0x10(%rsp)
cvtsd2ss %xmm0, %xmm0
mulss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
leal -0x1(,%rbx,2), %r15d
xorps %xmm1, %xmm1
movss 0x22499(%rip), %xmm0    # 0x3235c
testl %ebp, %ebp
js 0xfefb
movss %xmm1, 0x14(%rsp)
xorps %xmm1, %xmm1
cvtsi2ss %r14d, %xmm1
subss 0x10(%rsp), %xmm1
divss 0xc(%rsp), %xmm1
movaps %xmm1, %xmm0
mulss 0x2246c(%rip), %xmm0    # 0x32358
mulss %xmm1, %xmm0
callq 0x91a0
movss 0x14(%rsp), %xmm1
addss %xmm0, %xmm1
incl %r14d
decl %r15d
jne 0xfebb
leal -0x1(,%rbx,2), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss %xmm0, %xmm1
movaps %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/generic.c
// Function: vl_configuration_to_string_copy
char *
vl_configuration_to_string_copy ()
{
  char * string = 0 ;
  int length = 0 ;
  char * staticString = vl_static_configuration_to_string_copy() ;
  char * cpuString =
#if defined(VL_ARCH_IX86) || defined(VL_ARCH_X64) || defined(VL_ARCH_IA64)
  _vl_x86cpu_info_to_string_copy(&vl_get_state()->cpuInfo) ;
#else
  "Generic CPU" ;
#endif
#if defined(DEBUG)
  int const debug = 1 ;
#else
  int const debug = 0 ;
#endif

  while (string == 0) {
    if (length > 0) {
      string = vl_malloc(sizeof(char) * length) ;
      if (string == NULL) break ;
    }
    length = snprintf(string, length,
                      "VLFeat version %s\n"
                      "    Static config: %s\n"
                      "    %" VL_FMT_SIZE " CPU(s): %s\n"
#if defined(_OPENMP)
                      "    OpenMP: max threads: %d (library: %" VL_FMT_SIZE ")\n"
#endif
                      "    Debug: %s\n",
                      vl_get_version_string (),
                      staticString,
                      vl_get_num_cpus(), cpuString,
#if defined(_OPENMP)
                      omp_get_max_threads(), vl_get_max_threads(),
#endif
                      VL_YESNO(debug)) ;
    length += 1 ;
  }

  if (staticString) vl_free(staticString) ;
  if (cpuString) vl_free(cpuString) ;
  return string ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %eax, %eax
callq 0x93b0
movq %rax, %r14
leaq 0x2ab7c(%rip), %rdi     # 0x3b6a0
callq 0x17349
movq %rax, %rbx
leaq 0x218c4(%rip), %r12     # 0x323f7
leaq 0x218b6(%rip), %r13     # 0x323f0
xorl %ebp, %ebp
testl %ebp, %ebp
jle 0x10b52
movl %ebp, %edi
callq *0x2ab38(%rip)          # 0x3b680
movq %rax, %r15
testq %rax, %rax
jne 0x10b55
jmp 0x10b8b
xorl %r15d, %r15d
movslq %ebp, %rsi
movq 0x2ab81(%rip), %r9      # 0x3b6e0
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
xorl %eax, %eax
leaq 0x218ce(%rip), %r10     # 0x32442
pushq %r10
pushq %rbx
callq 0x9390
addq $0x10, %rsp
movl %eax, %ebp
incl %ebp
testq %r15, %r15
je 0x10b3c
jmp 0x10b8e
xorl %r15d, %r15d
testq %r14, %r14
je 0x10b9c
movq %r14, %rdi
callq *0x2aafc(%rip)          # 0x3b698
testq %rbx, %rbx
je 0x10baa
movq %rbx, %rdi
callq *0x2aaee(%rip)          # 0x3b698
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/generic.c
// Function: vl_set_last_error
int
vl_set_last_error (int error, char const * errorMessage, ...)
{
  VlThreadState * state = vl_get_thread_specific_state() ;
  va_list args;
  va_start(args, errorMessage) ;
  if (errorMessage) {
#ifdef VL_COMPILER_LCC
    vsprintf(state->lastErrorMessage, errorMessage, args) ;
#else
    vsnprintf(state->lastErrorMessage,
              sizeof(state->lastErrorMessage)/sizeof(char),
              errorMessage, args) ;
#endif
  } else {
    state->lastErrorMessage[0] = 0 ;
  }
  state->lastError = error ;
  va_end(args) ;
  return error ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movl %edi, %ebx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x10c60
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x10e14
movl 0x2a99d(%rip), %edi     # 0x3b608
callq 0x9200
movq %rax, %r15
testq %rax, %rax
jne 0x10ca6
movl $0xdd0, %edi            # imm = 0xDD0
callq 0x9ad8
movq %rax, %r15
movl $0x0, (%rax)
movb $0x0, 0x4(%rax)
movq $0x0, 0xdc8(%rax)
leaq 0x404(%rax), %rdi
callq 0x9a10
movl 0x2a95c(%rip), %edi     # 0x3b608
movq %r15, %rsi
callq 0x9a90
callq 0x10e99
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
leaq 0x4(%r15), %rdi
testq %r14, %r14
je 0x10cf9
movq %rsp, %rcx
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x91e0
jmp 0x10cfc
movb $0x0, (%rdi)
movl %ebx, (%r15)
movl %ebx, %eax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/generic.c
// Function: vl_set_alloc_func
void
vl_set_alloc_func (void *(*malloc_func)  (size_t),
                   void *(*realloc_func) (void*, size_t),
                   void *(*calloc_func)  (size_t, size_t),
                   void  (*free_func)    (void*))
{
  VlState * state ;
  vl_lock_state () ;
  state = vl_get_state() ;
  state->malloc_func  = malloc_func ;
  state->realloc_func = realloc_func ;
  state->calloc_func  = calloc_func ;
  state->free_func    = free_func ;
  vl_unlock_state () ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x10e14
movq %r12, 0x2a891(%rip)     # 0x3b680
movq %r15, 0x2a892(%rip)     # 0x3b688
movq %r14, 0x2a893(%rip)     # 0x3b690
movq %rbx, 0x2a894(%rip)     # 0x3b698
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10e99
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/generic.c
// Function: vl_lock_state
static void
vl_lock_state (void)
{
#if ! defined(VL_DISABLE_THREADS)
#if   defined(VL_THREADS_POSIX)
  VlState * state = vl_get_state () ;
  pthread_t thisThread = pthread_self () ;
  pthread_mutex_lock (&state->mutex) ;
  if (state->mutexCount >= 1 &&
      pthread_equal (state->mutexOwner, thisThread)) {
    state->mutexCount ++ ;
  } else {
    while (state->mutexCount >= 1) {
      pthread_cond_wait (&state->mutexCondition, &state->mutex) ;
    }
    state->mutexOwner = thisThread ;
    state->mutexCount = 1 ;
  }
  pthread_mutex_unlock (&state->mutex) ;
#elif defined(VL_THREADS_WIN)
  EnterCriticalSection (&vl_get_state()->mutex) ;
#endif
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x97a0
movq %rax, %rbx
leaq 0x2a7e8(%rip), %rdi     # 0x3b610
callq 0x9a40
movq 0x2a83c(%rip), %r14     # 0x3b670
testq %r14, %r14
je 0x10e74
movq 0x2a7f8(%rip), %rdi     # 0x3b638
movq %rbx, %rsi
callq 0x9780
testl %eax, %eax
je 0x10e51
incq %r14
jmp 0x10e81
leaq 0x2a7e8(%rip), %r14     # 0x3b640
leaq 0x2a7b1(%rip), %r15     # 0x3b610
movq %r14, %rdi
movq %r15, %rsi
callq 0x9260
cmpq $0x0, 0x2a7fe(%rip)     # 0x3b670
jne 0x10e5f
movq %rbx, 0x2a7bd(%rip)     # 0x3b638
movl $0x1, %r14d
movq %r14, 0x2a7e8(%rip)     # 0x3b670
leaq 0x2a781(%rip), %rdi     # 0x3b610
popq %rbx
popq %r14
popq %r15
jmp 0x9630
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_new
VlGMM *
vl_gmm_new (vl_type dataType, vl_size dimension, vl_size numComponents)
{
  vl_index i ;
  vl_size size = vl_get_type_size(dataType) ;
  VlGMM * self = vl_calloc(1, sizeof(VlGMM)) ;
  self->dataType = dataType;
  self->numClusters = numComponents ;
  self->numData = 0;
  self->dimension = dimension ;
  self->initialization = VlGMMRand;
  self->verbosity = 0 ;
  self->maxNumIterations = 50;
  self->numRepetitions = 1;
  self->sigmaLowBound =  NULL ;
  self->priors = NULL ;
  self->covariances = NULL ;
  self->means = NULL ;
  self->posteriors = NULL ;
  self->kmeansInit = NULL ;
  self->kmeansInitIsOwner = VL_FALSE;

  self->priors = vl_calloc (numComponents, size) ;
  self->means = vl_calloc (numComponents * dimension, size) ;
  self->covariances = vl_calloc (numComponents * dimension, size) ;
  self->sigmaLowBound = vl_calloc (dimension, sizeof(double)) ;

  for (i = 0 ; i < (unsigned)self->dimension ; ++i)  { self->sigmaLowBound[i] = 1e-4 ; }
  return self ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %r13d
leal -0x1(%r13), %eax
cmpl $0xa, %eax
jae 0x1170e
movq %rdx, %r15
movq %rsi, %r14
movl %eax, %eax
leaq 0x21344(%rip), %rcx     # 0x32900
movq (%rcx,%rax,8), %r12
movl $0x1, %edi
movl $0x80, %esi
callq 0x98f0
movq %rax, %rbx
movl %r13d, (%rax)
movq %r15, 0x10(%rax)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq %r14, 0x8(%rbx)
movl $0x1, 0x60(%rbx)
movl %eax, 0x30(%rbx)
movq $0x32, 0x20(%rbx)
movq $0x1, 0x28(%rbx)
movq %rax, 0x68(%rbx)
movl %eax, 0x78(%rbx)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x38(%rbx)
movdqu %xmm0, 0x48(%rbx)
movq %rax, 0x58(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x98f0
movq %rax, 0x48(%rbx)
imulq %r14, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x98f0
movq %rax, 0x38(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x98f0
movq %rax, 0x40(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x98f0
movq %rax, 0x58(%rbx)
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x11701
leaq -0x1(%rcx), %rdx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0x8(,%rcx,8), %rcx
andq $-0x10, %rcx
movdqa 0x2097a(%rip), %xmm1    # 0x32000
xorl %edx, %edx
movdqa 0x20980(%rip), %xmm2    # 0x32010
pxor %xmm2, %xmm0
movabsq $0x3f1a36e2eb1c432d, %rsi # imm = 0x3F1A36E2EB1C432D
pcmpeqd %xmm3, %xmm3
movdqa 0x20976(%rip), %xmm4    # 0x32020
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
movd %xmm5, %edi
notl %edi
testb $0x1, %dil
je 0x116e0
movq %rsi, (%rax,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x116f4
movq %rsi, 0x8(%rax,%rdx)
paddq %xmm4, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x116aa
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_reset
void
vl_gmm_reset (VlGMM * self)
{
  if (self->posteriors) {
    vl_free(self->posteriors) ;
    self->posteriors = NULL ;
    self->numData = 0 ;
  }
  if (self->kmeansInit && self->kmeansInitIsOwner) {
    vl_kmeans_delete(self->kmeansInit) ;
    self->kmeansInit = NULL ;
    self->kmeansInitIsOwner = VL_FALSE ;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x1172f
callq 0x9580
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movq %rax, 0x18(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x11752
cmpl $0x0, 0x78(%rbx)
je 0x11752
callq 0x9250
movq $0x0, 0x68(%rbx)
movl $0x0, 0x78(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_delete
void
vl_gmm_delete (VlGMM * self)
{
  if(self->means) vl_free(self->means);
  if(self->covariances) vl_free(self->covariances);
  if(self->priors) vl_free(self->priors);
  if(self->posteriors) vl_free(self->posteriors);
  if(self->kmeansInit && self->kmeansInitIsOwner) {
    vl_kmeans_delete(self->kmeansInit);
  }
  vl_free(self);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x11766
callq 0x9580
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x11774
callq 0x9580
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x11782
callq 0x9580
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x11790
callq 0x9580
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x117a4
cmpl $0x0, 0x78(%rbx)
je 0x117a4
callq 0x9250
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_set_kmeans_init_object
void vl_gmm_set_kmeans_init_object (VlGMM * self, VlKMeans * kmeans)
{
  if (self->kmeansInit && self->kmeansInitIsOwner) {
    vl_kmeans_delete(self->kmeansInit) ;
  }
  self->kmeansInit = kmeans;
  self->kmeansInitIsOwner = VL_FALSE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x11820
cmpl $0x0, 0x78(%rbx)
je 0x11820
callq 0x9250
movq %r14, 0x68(%rbx)
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_new_copy
VlGMM *
vl_gmm_new_copy (VlGMM const * self)
{
  vl_size size = vl_get_type_size(self->dataType) ;
  VlGMM * gmm = vl_gmm_new(self->dataType, self->dimension, self->numClusters);
  gmm->initialization = self->initialization;
  gmm->maxNumIterations = self->maxNumIterations;
  gmm->numRepetitions = self->numRepetitions;
  gmm->verbosity = self->verbosity;
  gmm->LL = self->LL;

  memcpy(gmm->means, self->means, size*self->numClusters*self->dimension);
  memcpy(gmm->covariances, self->covariances, size*self->numClusters*self->dimension);
  memcpy(gmm->priors, self->priors, size*self->numClusters);
  return gmm ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %edi
leal -0x1(%rdi), %eax
cmpl $0xa, %eax
jae 0x12140
movl %eax, %eax
leaq 0x20848(%rip), %rcx     # 0x32900
movq (%rcx,%rax,8), %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
callq 0x9700
movq %rax, %r15
movl 0x60(%rbx), %eax
movl %eax, 0x60(%r15)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x30(%rbx), %eax
movl %eax, 0x30(%r15)
movsd 0x70(%rbx), %xmm0
movsd %xmm0, 0x70(%r15)
movq 0x38(%r15), %rdi
movq 0x38(%rbx), %rsi
movq 0x10(%rbx), %rdx
imulq %r14, %rdx
imulq 0x8(%rbx), %rdx
callq 0x95a0
movq 0x40(%r15), %rdi
movq 0x40(%rbx), %rsi
movq 0x10(%rbx), %rdx
imulq %r14, %rdx
imulq 0x8(%rbx), %rdx
callq 0x95a0
movq 0x48(%r15), %rdi
movq 0x48(%rbx), %rsi
imulq 0x10(%rbx), %r14
movq %r14, %rdx
callq 0x95a0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_prepare_for_data
static void
_vl_gmm_prepare_for_data (VlGMM* self, vl_size numData)
{
  if (self->numData < numData) {
    vl_free(self->posteriors) ;
    self->posteriors = vl_malloc(vl_get_type_size(self->dataType) * numData * self->numClusters) ;
  }
  self->numData = numData ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jae 0x13b93
movq 0x50(%r14), %rdi
callq 0x9580
movl (%r14), %eax
decl %eax
cmpl $0xa, %eax
jae 0x13b9f
movl %eax, %eax
leaq 0x1ed83(%rip), %rcx     # 0x32900
movq (%rcx,%rax,8), %rdi
imulq %rbx, %rdi
imulq 0x10(%r14), %rdi
callq 0x95b0
movq %rax, 0x50(%r14)
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_apply_bounds_f
static void
VL_XCAT(_vl_gmm_apply_bounds_, SFX)(VlGMM * self)
{
  vl_uindex dim ;
  vl_uindex k ;
  vl_size numAdjusted = 0 ;
  TYPE * cov = (TYPE*)self->covariances ;
  double const * lbs = self->sigmaLowBound ;

  for (k = 0 ; k < self->numClusters ; ++k) {
    vl_bool adjusted = VL_FALSE ;
    for (dim = 0 ; dim < self->dimension ; ++dim) {
      if (cov[k * self->dimension + dim] < lbs[dim] ) {
        cov[k * self->dimension + dim] = lbs[dim] ;
        adjusted = VL_TRUE ;
      }
    }
    if (adjusted) { numAdjusted ++ ; }
  }

  if (numAdjusted > 0 && self->verbosity > 0) {
    VL_PRINT("gmm: detected %d of %d modes with at least one dimension "
             "with covariance too small (set to lower bound)\n",
             numAdjusted, self->numClusters) ;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x14255
movq %rdi, %rbx
movq 0x40(%rdi), %rcx
movq 0x58(%rdi), %rdx
movq 0x8(%rdi), %rsi
leaq (,%rsi,4), %rdi
xorl %r8d, %r8d
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x14218
xorl %r9d, %r9d
xorl %r10d, %r10d
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%r10,4), %xmm1
movsd (%rdx,%r10,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x14204
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%r10,4)
movl $0x1, %r9d
incq %r10
cmpq %r10, %rsi
jne 0x141df
xorl %r10d, %r10d
testl %r9d, %r9d
setne %r10b
jmp 0x1421b
xorl %r10d, %r10d
addq %r10, %r14
incq %r8
addq %rdi, %rcx
cmpq %rax, %r8
jne 0x141d4
testq %r14, %r14
je 0x14255
cmpl $0x0, 0x30(%rbx)
jle 0x14255
callq 0x9180
movq %rax, %rcx
movq 0x10(%rbx), %rdx
leaq 0x1e3ee(%rip), %rdi     # 0x32635
movq %r14, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/hikmeans.c
// Function: vl_hikm_copy_subset
vl_uint8*
vl_hikm_copy_subset (vl_uint8 const * data,
                     vl_uint32 *ids,
                     vl_size N, vl_size M,
                     vl_uint32 id, vl_size *N2)
{
  vl_uindex i ;
  vl_size count = 0;

  /* count how many data points with this label there are */
  for (i = 0 ; i < N ; i++) {
    if (ids[i] == id) {
      count ++ ;
    }
  }
  *N2 = count ;

  /* copy each datum to the buffer */
  {
    vl_uint8 *new_data = vl_malloc (sizeof(*new_data) * M * count);
    count = 0;
    for (i = 0 ; i < N ; i ++) {
      if (ids[i] == id) {
        memcpy(new_data + count * M,
               data + i * M,
               sizeof(*new_data) * M);
        count ++ ;
      }
    }
    *N2 = count ;
    return new_data ;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbp
testq %rdx, %rdx
je 0x1499f
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %eax, %eax
xorl %edi, %edi
xorl %ecx, %ecx
cmpl %r8d, (%r12,%rax,4)
sete %cl
addq %rcx, %rdi
incq %rax
cmpq %rax, %r15
jne 0x14916
movq %rbp, 0x8(%rsp)
movq %rdi, (%rbp)
imulq %r14, %rdi
movl %r8d, 0x4(%rsp)
callq 0x95b0
movl 0x4(%rsp), %ecx
xorl %ebp, %ebp
xorl %ebx, %ebx
cmpl %ecx, (%r12,%rbp,4)
jne 0x1498d
movq %rbx, %rdi
imulq %r14, %rdi
addq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, 0x10(%rsp)
movq %r15, %rbx
movq %r12, %r15
movq %r14, %r12
movq %rax, %r14
callq 0x95a0
movq %r14, %rax
movq %r12, %r14
movq %r15, %r12
movq %rbx, %r15
movq 0x10(%rsp), %rbx
movl 0x4(%rsp), %ecx
incq %rbx
incq %rbp
addq %r14, %r13
cmpq %rbp, %r15
jne 0x14949
movq 0x8(%rsp), %rbp
jmp 0x149b0
movq $0x0, (%rbp)
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x95b0
movq %rbx, (%rbp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x14a63
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x14a47
movq (%rbx), %rdi
callq 0x9740
testq %rax, %rax
je 0x14a3e
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x149fe
incq %r14
movq (%rbx), %rdi
callq 0x9740
cmpq %rax, %r14
jb 0x14a21
movq 0x8(%rbx), %rdi
callq 0x9580
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x14a54
callq 0x9240
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x28(%rdi), %rdi
callq 0x149fe
movq $0x0, 0x28(%r12)
movq %r15, (%r12)
movq %r14, 0x8(%r12)
movq %rbx, 0x10(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq %rcx, 0x30(%rsp)
testq %rcx, %rcx
je 0x14d59
movq %rsi, %r14
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rax, 0x28(%rsp)
xorl %ebx, %ebx
leaq 0xc(%rsp), %r13
movq 0x10(%rsp), %rax
movq 0x28(%rax), %r12
testq %r12, %r12
je 0x14d4a
movq %rbx, %rbp
imulq 0x18(%rsp), %rbp
addq 0x20(%rsp), %rbp
movq %r14, %r15
movq (%r12), %rdi
movl $0x1, %ecx
movq %r13, %rsi
movq %rbp, %rdx
callq 0x9070
movl 0xc(%rsp), %eax
movl %eax, (%r15)
movq 0x8(%r12), %rcx
testq %rcx, %rcx
je 0x14d4a
movq (%rcx,%rax,8), %r12
addq $0x4, %r15
testq %r12, %r12
jne 0x14d18
incq %rbx
addq 0x28(%rsp), %r14
cmpq 0x30(%rsp), %rbx
jne 0x14cf9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x1532e
callq 0x9580
movq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x15344
callq 0x9580
movq $0x0, 0x40(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1535a
callq 0x9580
movq $0x0, 0x28(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x15370
callq 0x9580
movq $0x0, 0x20(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x15386
callq 0x9580
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1539c
callq 0x9580
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/homkermap.c
// Function: vl_homogeneouskernelmap_evaluate_f
void
VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)
(VlHomogeneousKernelMap const * self,
 T * destination,
 vl_size stride,
 double x)
{
  /* break value into exponent and mantissa */
  int exponent ;
  int unsigned j ;
  double mantissa = frexp(x, &exponent) ;
  double sign = (mantissa >= 0.0) ? +1.0 : -1.0 ;
  mantissa *= 2*sign ;
  exponent -- ;

  if (mantissa == 0 ||
      exponent <= self->minExponent ||
      exponent >= self->maxExponent) {
    for (j = 0 ; j < 2*self->order+1 ; ++j) {
      *destination = (T) 0.0 ;
      destination += stride ;
    }
    return  ;
  }
  {
    vl_size featureDimension = 2*self->order + 1 ;
    double const * v1 = self->table +
    (exponent - self->minExponent) * self->numSubdivisions * featureDimension ;
    double const * v2 ;
    double f1, f2 ;

    mantissa -= 1.0 ;
    while (mantissa >= self->subdivision) {
      mantissa -= self->subdivision ;
      v1 += featureDimension ;
    }
    v2 = v1 + featureDimension ;
    for (j = 0 ; j < featureDimension ; ++j) {
      f1 = *v1++ ;
      f2 = *v2++ ;
      *destination = (T) sign * ((f2 - f1) * (self->numSubdivisions * mantissa) + f1) ;
      destination += stride ;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0xc(%rsp), %rdi
callq 0x94d0
xorpd %xmm3, %xmm3
xorl %eax, %eax
ucomisd %xmm3, %xmm0
setae %al
leaq 0x1b984(%rip), %rcx     # 0x329f0
movsd (%rcx,%rax,8), %xmm2
movapd %xmm2, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
ucomisd %xmm3, %xmm1
jne 0x17085
jnp 0x170d6
movslq 0xc(%rsp), %rax
decq %rax
movq %rax, %rdx
subq 0x38(%r15), %rdx
jle 0x170d6
cmpq %rax, 0x40(%r15)
jle 0x170d6
movq 0x18(%r15), %rax
movq 0x28(%r15), %rsi
leaq (%rax,%rax), %rcx
addsd 0x1b158(%rip), %xmm1    # 0x32208
movq 0x48(%r15), %rdi
movsd 0x30(%r15), %xmm0
ucomisd %xmm0, %xmm1
jae 0x17103
leaq 0x1(,%rax,2), %r8
imulq %rsi, %r8
imulq %rdx, %r8
leaq (%rdi,%r8,8), %rdx
jmp 0x1712b
movq 0x18(%r15), %rax
addq %rax, %rax
shlq $0x2, %rbx
movl $0x1, %ecx
movl $0x0, (%r14)
movl %ecx, %edx
addq %rbx, %r14
incl %ecx
cmpq %rdx, %rax
jae 0x170e6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
imulq %rsi, %rdx
leaq 0x1(%rcx), %r8
imulq %rdx, %r8
leaq (%rdi,%r8,8), %rdx
movq %rax, %rdi
shlq $0x4, %rdi
orq $0x8, %rdi
addq %rdi, %rdx
subsd %xmm0, %xmm1
ucomisd %xmm0, %xmm1
jae 0x1711e
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movq %rsi, %xmm3
punpckldq 0x1b03d(%rip), %xmm3 # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
subpd 0x1b045(%rip), %xmm3    # 0x32190
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
addsd %xmm3, %xmm2
mulsd %xmm1, %xmm2
shlq $0x2, %rbx
shlq $0x4, %rax
addq %rdx, %rax
movl $0x1, %esi
movsd -0x8(%rdx,%rsi,8), %xmm1
movsd (%rax,%rsi,8), %xmm3
subsd %xmm1, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
mulsd %xmm0, %xmm3
xorps %xmm1, %xmm1
cvtsd2ss %xmm3, %xmm1
movss %xmm1, (%r14)
movl %esi, %edi
addq %rbx, %r14
incq %rsi
cmpq %rdi, %rcx
jae 0x1716b
jmp 0x170f9