LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xf005
cvtsi2ss %r15d, %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %ebx, %xmm0
decl %ebp
cvtsi2ss %ebp, %xmm2
mulss 0x243f0(%rip), %xmm2    # 0x33348
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 0x243b4(%rip), %xmm2    # 0x3334c
leal (%r12,%r13), %eax
xorps %xmm3, %xmm3
cvtsi2ss %eax, %xmm3
movaps %xmm2, %xmm0
testl %ebx, %ebx
js 0xefdf
movaps %xmm3, %xmm1
subss 0x8(%rsp), %xmm1
divss 0x4(%rsp), %xmm1
movaps %xmm1, %xmm0
mulss 0x24384(%rip), %xmm0    # 0x33348
mulss %xmm1, %xmm0
movaps %xmm3, 0x10(%rsp)
callq 0x91a0
movaps 0x10(%rsp), %xmm3
movss 0x2436d(%rip), %xmm2    # 0x3334c
andps 0x2418a(%rip), %xmm3    # 0x33170
divss 0xc(%rsp), %xmm3
movaps %xmm2, %xmm1
subss %xmm3, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r14,%r13,4)
incq %r13
cmpl %r13d, %r15d
jne 0xef98
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_O1/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_update_buffers
VL_EXPORT void
_vl_dsift_update_buffers (VlDsiftFilter * self)
{
  int x1 = self->boundMinX ;
  int x2 = self->boundMaxX ;
  int y1 = self->boundMinY ;
  int y2 = self->boundMaxY ;

  int rangeX = x2 - x1 - (self->geom.numBinX - 1) * self->geom.binSizeX ;
  int rangeY = y2 - y1 - (self->geom.numBinY - 1) * self->geom.binSizeY ;

  int numFramesX = (rangeX >= 0) ? rangeX / self->stepX + 1 : 0 ;
  int numFramesY = (rangeY >= 0) ? rangeY / self->stepY + 1 : 0 ;

  self->numFrames = numFramesX * numFramesY ;
  self->descrSize = self->geom.numBinT *
                    self->geom.numBinX *
                    self->geom.numBinY ;
}

// Assembly:
movl 0x18(%rdi), %eax
movl 0x1c(%rdi), %ecx
movl 0x24(%rdi), %r9d
movl $0x1, %edx
movl $0x1, %r8d
subl %r9d, %r8d
imull 0x2c(%rdi), %r8d
subl 0x10(%rdi), %eax
movl 0x28(%rdi), %r10d
subl %r10d, %edx
imull 0x30(%rdi), %edx
subl 0x14(%rdi), %ecx
addl %edx, %ecx
xorl %esi, %esi
addl %r8d, %eax
movl $0x0, %r8d
js 0xf05e
cltd
idivl 0x8(%rdi)
movl %eax, %r8d
incl %r8d
testl %ecx, %ecx
js 0xf06c
movl %ecx, %eax
cltd
idivl 0xc(%rdi)
movl %eax, %esi
incl %esi
imull %r8d, %esi
movl %esi, 0x40(%rdi)
imull %r9d, %r10d
imull 0x20(%rdi), %r10d
movl %r10d, 0x44(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x242d8(%rip), %xmm0    # 0x33380
movups %xmm0, 0x8(%rax)
leal -0x1(%r15), %eax
movl %eax, 0x18(%rbx)
leal -0x1(%r14), %eax
movl %eax, 0x1c(%rbx)
movaps 0x242cf(%rip), %xmm0    # 0x33390
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_O1/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_new_basic
VL_EXPORT VlDsiftFilter *
vl_dsift_new_basic (int imWidth, int imHeight, int step, int binSize)
{
  VlDsiftFilter* self = vl_dsift_new(imWidth, imHeight) ;
  VlDsiftDescriptorGeometry geom = *vl_dsift_get_geometry(self) ;
  geom.binSizeX = binSize ;
  geom.binSizeY = binSize ;
  vl_dsift_set_geometry(self, &geom) ;
  vl_dsift_set_steps(self, step, step) ;
  return self ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
callq 0x9960
movq %rax, %r14
movl %ebx, 0x2c(%rax)
movl %ebx, 0x30(%rax)
movq %rax, %rdi
callq 0x9790
movl %ebp, 0x8(%r14)
movl %ebp, 0xc(%r14)
movq %r14, %rdi
callq 0x9790
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf199
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xf182
callq 0x9580
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0xf190
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O1/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 0xf1b6
callq 0x9580
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0xf1cc
callq 0x9580
movq $0x0, 0x50(%rbx)
cmpq $0x0, 0x68(%rbx)
je 0xf20b
cmpl $0x0, 0x60(%rbx)
jle 0xf1fa
xorl %r14d, %r14d
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xf1ee
callq 0x9580
incq %r14
movslq 0x60(%rbx), %rax
cmpq %rax, %r14
jl 0xf1dc
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_O1/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 0xfe12
movl %edx, %ebp
xorps %xmm1, %xmm1
cvtsi2ss %ebx, %xmm1
cvtsi2ss %edx, %xmm2
decl %esi
cvtsi2ss %esi, %xmm3
mulss 0x235a9(%rip), %xmm3    # 0x33348
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 0x2357e(%rip), %xmm0    # 0x3334c
testl %ebp, %ebp
js 0xfe06
movss %xmm1, 0x14(%rsp)
xorps %xmm1, %xmm1
cvtsi2ss %r14d, %xmm1
subss 0x10(%rsp), %xmm1
divss 0xc(%rsp), %xmm1
movaps %xmm1, %xmm0
mulss 0x23551(%rip), %xmm0    # 0x33348
mulss %xmm1, %xmm0
callq 0x91a0
movss 0x14(%rsp), %xmm1
addss %xmm0, %xmm1
incl %r14d
decl %r15d
jne 0xfdc6
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_O1/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 0x2bc70(%rip), %rdi     # 0x3c6a0
callq 0x17429
movq %rax, %rbx
leaq 0x229a8(%rip), %r12     # 0x333e7
leaq 0x2299a(%rip), %r13     # 0x333e0
xorl %ebp, %ebp
testl %ebp, %ebp
jle 0x10a5e
movl %ebp, %edi
callq *0x2bc2c(%rip)          # 0x3c680
movq %rax, %r15
testq %rax, %rax
jne 0x10a61
jmp 0x10a97
xorl %r15d, %r15d
movslq %ebp, %rsi
movq 0x2bc75(%rip), %r9      # 0x3c6e0
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
xorl %eax, %eax
leaq 0x229b2(%rip), %r10     # 0x33432
pushq %r10
pushq %rbx
callq 0x9390
addq $0x10, %rsp
movl %eax, %ebp
incl %ebp
testq %r15, %r15
je 0x10a48
jmp 0x10a9a
xorl %r15d, %r15d
testq %r14, %r14
je 0x10aa8
movq %r14, %rdi
callq *0x2bbf0(%rip)          # 0x3c698
testq %rbx, %rbx
je 0x10ab6
movq %rbx, %rdi
callq *0x2bbe2(%rip)          # 0x3c698
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_O1/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 0x10b6c
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 0x10d20
movl 0x2ba91(%rip), %edi     # 0x3c608
callq 0x9200
movq %rax, %r15
testq %rax, %rax
jne 0x10bb2
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 0x2ba50(%rip), %edi     # 0x3c608
movq %r15, %rsi
callq 0x9a90
callq 0x10daf
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 0x10c05
movq %rsp, %rcx
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x91e0
jmp 0x10c08
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_O1/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 0x10d20
movq %r12, 0x2b985(%rip)     # 0x3c680
movq %r15, 0x2b986(%rip)     # 0x3c688
movq %r14, 0x2b987(%rip)     # 0x3c690
movq %rbx, 0x2b988(%rip)     # 0x3c698
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10daf
// File: /workspace/github_c_makefile_star2_O1/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 0x2b8dc(%rip), %rdi     # 0x3c610
callq 0x9a40
movq 0x2b930(%rip), %r14     # 0x3c670
testq %r14, %r14
je 0x10d5d
movq 0x2b8ec(%rip), %rdi     # 0x3c638
movq %rbx, %rsi
callq 0x9780
testl %eax, %eax
je 0x10d5d
incq %r14
jmp 0x10d97
cmpq $0x0, 0x2b90b(%rip)     # 0x3c670
je 0x10d8a
leaq 0x2b8d2(%rip), %r14     # 0x3c640
leaq 0x2b89b(%rip), %r15     # 0x3c610
movq %r14, %rdi
movq %r15, %rsi
callq 0x9260
cmpq $0x0, 0x2b8e8(%rip)     # 0x3c670
jne 0x10d75
movq %rbx, 0x2b8a7(%rip)     # 0x3c638
movl $0x1, %r14d
movq %r14, 0x2b8d2(%rip)     # 0x3c670
leaq 0x2b86b(%rip), %rdi     # 0x3c610
popq %rbx
popq %r14
popq %r15
jmp 0x9630
// File: /workspace/github_c_makefile_star2_O1/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 0x11632
movq %rdx, %r15
movq %rsi, %r14
movl %eax, %eax
leaq 0x22420(%rip), %rcx     # 0x33900
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 0x11625
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 0x21a56(%rip), %xmm1    # 0x33000
xorl %edx, %edx
movdqa 0x21a5c(%rip), %xmm2    # 0x33010
pxor %xmm2, %xmm0
movabsq $0x3f1a36e2eb1c432d, %rsi # imm = 0x3F1A36E2EB1C432D
pcmpeqd %xmm3, %xmm3
movdqa 0x21a52(%rip), %xmm4    # 0x33020
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 0x11604
movq %rsi, (%rax,%rdx)
pxor %xmm3, %xmm5
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x11618
movq %rsi, 0x8(%rax,%rdx)
paddq %xmm4, %xmm1
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0x115ce
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O1/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 0x11653
callq 0x9580
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movq %rax, 0x18(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x11676
cmpl $0x0, 0x78(%rbx)
je 0x11676
callq 0x9250
movq $0x0, 0x68(%rbx)
movl $0x0, 0x78(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1168a
callq 0x9580
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x11698
callq 0x9580
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x116a6
callq 0x9580
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x116b4
callq 0x9580
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x116c8
cmpl $0x0, 0x78(%rbx)
je 0x116c8
callq 0x9250
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O1/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 0x11744
cmpl $0x0, 0x78(%rbx)
je 0x11744
callq 0x9250
movq %r14, 0x68(%rbx)
movl $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12054
movl %eax, %eax
leaq 0x21934(%rip), %rcx     # 0x33900
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_O1/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 0x13b75
movq 0x50(%r14), %rdi
callq 0x9580
movl (%r14), %eax
decl %eax
cmpl $0xa, %eax
jae 0x13b81
movl %eax, %eax
leaq 0x1fda1(%rip), %rcx     # 0x33900
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_O1/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 %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1424e
movq 0x40(%rbx), %rcx
movq 0x58(%rbx), %rdx
movq 0x8(%rbx), %rsi
leaq (,%rsi,4), %rdi
xorl %r8d, %r8d
xorl %r14d, %r14d
testq %rsi, %rsi
je 0x1423b
xorl %r9d, %r9d
xorl %r10d, %r10d
xorps %xmm1, %xmm1
cvtss2sd (%rcx,%r10,4), %xmm1
movsd (%rdx,%r10,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x14227
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rcx,%r10,4)
movl $0x1, %r9d
incq %r10
cmpq %r10, %rsi
jne 0x14202
xorl %r10d, %r10d
testl %r9d, %r9d
setne %r10b
jmp 0x1423e
xorl %r10d, %r10d
addq %r10, %r14
incq %r8
addq %rdi, %rcx
cmpq %rax, %r8
jne 0x141f7
jmp 0x14251
xorl %r14d, %r14d
testq %r14, %r14
je 0x1427d
cmpl $0x0, 0x30(%rbx)
jle 0x1427d
callq 0x9180
movq %rax, %rcx
movq 0x10(%rbx), %rdx
leaq 0x1f3c6(%rip), %rdi     # 0x33635
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_O1/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 %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
testq %rdx, %rdx
je 0x14991
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 0x1497b
jmp 0x14993
xorl %edi, %edi
movl %r8d, 0x4(%rsp)
movq %r9, 0x10(%rsp)
movq %rdi, (%r9)
imulq %r14, %rdi
callq 0x95b0
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x149ec
xorl %ebp, %ebp
xorl %ebx, %ebx
movl 0x4(%rsp), %eax
cmpl %eax, (%r12,%rbp,4)
jne 0x149df
movq %rbx, %rdi
imulq %r14, %rdi
addq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x95a0
movl 0x4(%rsp), %eax
incq %rbx
incq %rbp
addq %r14, %r13
cmpq %rbp, %r15
jne 0x149bb
jmp 0x149ee
xorl %ebx, %ebx
movq 0x10(%rsp), %rax
movq %rbx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movl %edi, %ebx
movl $0x30, %edi
movl $0x1, %esi
callq 0x98f0
movq $0xc8, 0x18(%rax)
movl %ebx, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14aaa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x14a8e
movq (%rbx), %rdi
callq 0x9740
testq %rax, %rax
je 0x14a85
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x14a45
incq %r14
movq (%rbx), %rdi
callq 0x9740
cmpq %rax, %r14
jb 0x14a68
movq 0x8(%rbx), %rdi
callq 0x9580
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x14a9b
callq 0x9240
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14a45
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_O1/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, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
movq %rcx, 0x30(%rsp)
testq %rcx, %rcx
je 0x14d9f
movq %rsi, %rbx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
shlq $0x2, %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
leaq 0xc(%rsp), %r13
movq 0x10(%rsp), %rax
movq 0x28(%rax), %r12
movq %r14, %rbp
imulq 0x20(%rsp), %rbp
addq 0x28(%rsp), %rbp
movq %rbx, %r15
testq %r12, %r12
je 0x14d90
movq (%r12), %rdi
movl $0x1, %ecx
movq %r13, %rsi
movq %rbp, %rdx
callq 0x9070
movl 0xc(%rsp), %ecx
movl %ecx, (%r15)
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x14d87
movq (%rax,%rcx,8), %r12
addq $0x4, %r15
testq %rax, %rax
jne 0x14d59
incq %r14
addq 0x18(%rsp), %rbx
cmpq 0x30(%rsp), %r14
jne 0x14d3f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15376
callq 0x9580
movq $0x0, 0x38(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x1538c
callq 0x9580
movq $0x0, 0x40(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x153a2
callq 0x9580
movq $0x0, 0x28(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x153b8
callq 0x9580
movq $0x0, 0x20(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x153ce
callq 0x9580
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x153e4
callq 0x9580
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r8
movq %rdi, %rbx
movq %rcx, %rdi
shrq %rdi
leaq (%rsi,%rdi), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r14
addq %r8, %rdi
movq %rdi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %r15
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x15d18
cmpq %r14, 0x58(%rbx)
jne 0x15d06
cmpq %r15, 0x60(%rbx)
jne 0x15d06
imulq %r15, %r14
shlq $0x2, %r14
movq 0x10(%rbx), %rdx
imulq %r14, %rdx
addq %rdx, %rdx
xorl %esi, %esi
callq 0x9400
movq 0x50(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9400
testq %rdi, %rdi
je 0x15d18
callq 0x9580
movq $0x0, 0x48(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x15d2e
callq 0x9580
movq $0x0, 0x50(%rbx)
movq %r15, %r12
imulq %r14, %r12
movq 0x10(%rbx), %rdi
imulq %r12, %rdi
addq %rdi, %rdi
movl $0x4, %esi
callq 0x98f0
movq %rax, 0x48(%rbx)
movl $0x4, %esi
movq %r12, %rdi
callq 0x98f0
movq %rax, 0x50(%rbx)
movq %r14, 0x58(%rbx)
movq %r15, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0x94d0
xorpd %xmm3, %xmm3
xorl %eax, %eax
ucomisd %xmm3, %xmm0
setae %al
leaq 0x1c8be(%rip), %rcx     # 0x33a00
movsd (%rcx,%rax,8), %xmm2
movapd %xmm2, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movslq (%r12), %rax
decq %rax
movl %eax, (%r12)
ucomisd %xmm3, %xmm1
jne 0x17166
jnp 0x171af
movq %rax, %rdx
subq 0x38(%r15), %rdx
jle 0x171af
cmpq %rax, 0x40(%r15)
jle 0x171af
movq 0x18(%r15), %rax
movq 0x28(%r15), %rsi
leaq (%rax,%rax), %rcx
addsd 0x1c06f(%rip), %xmm1    # 0x331f8
movq 0x48(%r15), %rdi
movsd 0x30(%r15), %xmm0
ucomisd %xmm0, %xmm1
jae 0x171de
leaq 0x1(,%rax,2), %r8
imulq %rsi, %r8
imulq %rdx, %r8
leaq (%rdi,%r8,8), %rdx
jmp 0x17206
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 0x171bf
addq $0x8, %rsp
popq %rbx
popq %r12
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 0x171f9
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movq %rsi, %xmm3
punpckldq 0x1bf62(%rip), %xmm3 # xmm3 = xmm3[0],mem[0],xmm3[1],mem[1]
subpd 0x1bf6a(%rip), %xmm3    # 0x33190
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 0x17246
jmp 0x171d2
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/host.c
// Function: vl_x86cpu_info_init
VL_INLINE void
_vl_cpuid (vl_int32* info, int function)
{
#if defined(VL_ARCH_IX86) && (defined(__PIC__) || defined(__pic__))
  /* This version is compatible with -fPIC on x386 targets. This special
   * case is required becaus
   * on such platform -fPIC alocates ebx as global offset table pointer.
   * Note that =r below will be mapped to a register different from ebx,
   * so the code is sound. */
  __asm__ __volatile__
  ("pushl %%ebx      \n" /* save %ebx */
   "cpuid            \n"
   "movl %%ebx, %1   \n" /* save what cpuid just put in %ebx */
   "popl %%ebx       \n" /* restore the old %ebx */
   : "=a"(info[0]), "=r"(info[1]), "=c"(info[2]), "=d"(info[3])
   : "a"(function)
   : "cc") ; /* clobbered (cc=condition codes) */
#else /* no -fPIC or -fPIC with a 64-bit target */
  __asm__ __volatile__
  ("cpuid"
   : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3])
   : "a"(function)
   : "cc") ;
#endif
}

// Assembly:
pushq %rbx
xorl %eax, %eax
cpuid
movl %ebx, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
testl %eax, %eax
jle 0x17427
movl $0x1, %eax
cpuid
movl %edx, %eax
andl $0x800000, %eax         # imm = 0x800000
movl %eax, 0x38(%rdi)
movl %edx, %eax
andl $0x2000000, %eax        # imm = 0x2000000
movl %eax, 0x34(%rdi)
andl $0x4000000, %edx        # imm = 0x4000000
movl %edx, 0x30(%rdi)
movd %ecx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
pand 0x1c67e(%rip), %xmm0    # 0x33aa0
movdqu %xmm0, 0x20(%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1c3ca(%rip), %r12     # 0x33808
xorl %ebp, %ebp
testl %ebp, %ebp
jle 0x17458
movl %ebp, %edi
callq 0x95b0
movq %rax, %r15
testq %rax, %rax
jne 0x1745b
jmp 0x17503
xorl %r15d, %r15d
cmpl $0x0, 0x38(%rbx)
leaq 0x1c66b(%rip), %r8      # 0x33ad1
cmoveq %r12, %r8
cmpl $0x0, 0x34(%rbx)
leaq 0x1c661(%rip), %r9      # 0x33ad6
cmoveq %r12, %r9
cmpl $0x0, 0x30(%rbx)
leaq 0x1c691(%rip), %r10     # 0x33b15
cmoveq %r12, %r10
movslq %ebp, %rsi
movdqu 0x20(%rbx), %xmm0
pcmpeqd 0x1c618(%rip), %xmm0    # 0x33ab0
movmskps %xmm0, %eax
testb $0x8, %al
leaq 0x1c637(%rip), %r11     # 0x33adb
cmovneq %r12, %r11
testb $0x4, %al
leaq 0x1c630(%rip), %rbp     # 0x33ae1
cmovneq %r12, %rbp
testb $0x2, %al
leaq 0x1c62a(%rip), %r13     # 0x33ae8
cmovneq %r12, %r13
testb $0x1, %al
leaq 0x1c624(%rip), %r14     # 0x33aef
cmovneq %r12, %r14
subq $0x8, %rsp
movq %r15, %rdi
leaq 0x1c5e3(%rip), %rdx     # 0x33ac0
movq %rbx, %rcx
xorl %eax, %eax
pushq %r14
pushq %r13
pushq %rbp
pushq %r11
pushq %r10
callq 0x9390
addq $0x30, %rsp
movl %eax, %ebp
incl %ebp
testq %r15, %r15
je 0x17440
jmp 0x17506
xorl %r15d, %r15d
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_O1/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:
pushq %rbx
movl %edi, %ebx
movl $0x30, %edi
movl $0x1, %esi
callq 0x98f0
movl %ebx, 0x18(%rax)
movq $0xc8, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x17601
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x175ea
callq 0x9580
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x175f8
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r8
movq %rdx, (%rsp)
movl 0x18(%rdi), %eax
cmpl $0x1, %eax
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
je 0x181c8
testl %eax, %eax
jne 0x18288
testq %r8, %r8
je 0x18279
movq 0x20(%rdi), %r12
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
xorl %r15d, %r15d
movq %r12, %rdi
movq (%rsp), %rbx
movq %rbx, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x9030
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
addq %r13, %rbx
movq %rbx, (%rsp)
cmpq %r15, 0x10(%rsp)
jne 0x18194
jmp 0x18279
testq %r8, %r8
je 0x18279
movq 0x28(%rdi), %rax
movq 0x8(%rdi), %r14
xorl %ecx, %ecx
movl $0x0, %edx
testq %r14, %r14
je 0x1826a
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %edx, %edx
movq (%rsp), %rsi
movq %rdx, %r11
imulq %r14, %r11
leaq (%rax,%r11,4), %r11
cmpl %r8d, (%r11,%r10,4)
jge 0x18254
movq (%rdi), %r11
testq %r11, %r11
je 0x18247
movq %r11, %r12
imulq %r9, %r12
addq 0x20(%rdi), %r12
movq %rcx, %r13
imulq %r11, %r13
addq %rsi, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movzbl (%r13,%r15), %ebx
subl (%r12,%r15,4), %ebx
imull %ebx, %ebx
addl %ebx, %ebp
incq %r15
cmpq %r15, %r11
jne 0x1822e
jmp 0x18249
xorl %ebp, %ebp
cmpl %r8d, %ebp
cmovlq %r10, %rdx
cmovll %ebp, %r8d
incq %r10
addq $0x4, %r9
cmpq %r14, %r10
jne 0x181fb
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
movl %edx, (%rsi,%rcx,4)
incq %rcx
cmpq %r8, %rcx
jne 0x181db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rcx, %rcx
je 0x182f5
pushq %rbp
pushq %rbx
leaq (,%rdx,4), %r8
movq $-0x1, %rax
xorl %r9d, %r9d
xorl %r10d, %r10d
movl $0x0, %r11d
testq %rdx, %rdx
je 0x182ce
xorl %ebx, %ebx
xorl %r11d, %r11d
movzbl (%rsi,%rbx), %ebp
subl (%rdi,%rbx,4), %ebp
imull %ebp, %ebp
addl %ebp, %r11d
incq %rbx
cmpq %rbx, %rdx
jne 0x182b9
cmpq $-0x1, %rax
sete %bl
cmpl %r9d, %r11d
setl %bpl
orb %bl, %bpl
cmovneq %r10, %rax
cmovnel %r11d, %r9d
incq %r10
addq %r8, %rdi
cmpq %rcx, %r10
jne 0x182a9
popq %rbx
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/imopv.c
// Function: vl_imsmooth_f
VL_EXPORT void
VL_XCAT(vl_imsmooth_, SFX)
(T * smoothed, vl_size smoothedStride,
 T const *image, vl_size width, vl_size height, vl_size stride,
 double sigmax, double sigmay)
{
  T *filterx, *filtery, *buffer ;
  vl_size sizex, sizey ;

  filterx = VL_XCAT(_vl_new_gaussian_fitler_,SFX)(&sizex,sigmax) ;
  if (sigmax == sigmay) {
    filtery = filterx ;
    sizey = sizex ;
  } else {
    filtery = VL_XCAT(_vl_new_gaussian_fitler_,SFX)(&sizey,sigmay) ;
  }
  buffer = vl_malloc(width*height*sizeof(T)) ;

  VL_XCAT(vl_imconvcol_v,SFX) (buffer, height,
                               image, width, height, stride,
                               filtery,
                               -((signed)sizey-1)/2, ((signed)sizey-1)/2,
                               1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;

  VL_XCAT(vl_imconvcol_v,SFX) (smoothed, smoothedStride,
                               buffer, height, width, height,
                               filterx,
                               -((signed)sizex-1)/2, ((signed)sizex-1)/2,
                               1, VL_PAD_BY_CONTINUITY | VL_TRANSPOSE) ;

  vl_free(buffer) ;
  vl_free(filterx) ;
  if (sigmax != sigmay) {
    vl_free(filtery) ;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm1, (%rsp)
movsd %xmm0, 0x8(%rsp)
movq %r9, 0x20(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x19339
movsd (%rsp), %xmm0
movq %rax, %rbx
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x19220
jp 0x19220
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %r14
jmp 0x1922d
leaq 0x10(%rsp), %rdi
callq 0x19339
movq %rax, %r14
movq %r12, %rdi
imulq %r15, %rdi
shlq $0x2, %rdi
callq 0x95b0
movq %rax, %r13
movl 0x10(%rsp), %eax
leal -0x1(%rax), %ecx
movl $0x1, %edx
subl %eax, %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
movslq %esi, %r10
shrl $0x1f, %ecx
addl %ecx, %eax
decl %eax
sarl %eax
cltq
subq $0x8, %rsp
movl $0x5, %r11d
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x28(%rsp), %r9
pushq %r11
movl $0x1, %r11d
pushq %r11
movl $0x1, %ebp
pushq %rax
pushq %r10
pushq %r14
callq 0x92b0
addq $0x30, %rsp
movl 0x18(%rsp), %eax
leal -0x1(%rax), %ecx
movl $0x1, %edx
subl %eax, %edx
movl %edx, %esi
shrl $0x1f, %esi
addl %edx, %esi
sarl %esi
movslq %esi, %r10
shrl $0x1f, %ecx
addl %ecx, %eax
decl %eax
sarl %eax
cltq
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r15, %r9
movl $0x5, %r11d
pushq %r11
pushq %rbp
pushq %rax
pushq %r10
pushq %rbx
callq 0x92b0
addq $0x30, %rsp
movq %r13, %rdi
callq 0x9580
movq %rbx, %rdi
callq 0x9580
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jne 0x19314
jnp 0x1932a
movq %r14, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9580
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq