LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_compare_orientations_descending
static int
_vl_covdet_compare_orientations_descending (void const * a_,
                                            void const * b_)
{
  VlCovDetFeatureOrientation const * a = a_ ;
  VlCovDetFeatureOrientation const * b = b_ ;
  if (a->score > b->score) return -1 ;
  if (a->score < b->score) return +1 ;
  return 0 ;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq -0x28(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0x12c7e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x12caa
movq -0x20(%rsp), %rax
movsd 0x8(%rax), %xmm1
movq -0x28(%rsp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x12ca2
movl $0x1, -0x4(%rsp)
jmp 0x12caa
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x60(%rsp), %rdi
callq 0x9390
movq %rax, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq 0x40(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x13b8c
movq 0x60(%rsp), %rdi
movq 0x60(%rsp), %rax
movq 0x50(%rax), %rax
imulq $0x28, 0x50(%rsp), %rcx
addq %rcx, %rax
movsd 0x58(%rsp), %xmm0
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x13600
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x13b77
movq 0x60(%rsp), %rax
movq 0x50(%rax), %rdi
imulq $0x28, 0x48(%rsp), %rax
addq %rax, %rdi
movq 0x60(%rsp), %rax
movq 0x50(%rax), %rsi
imulq $0x28, 0x50(%rsp), %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x9640
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x13b79
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x13ac0
movq 0x48(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x58(%rax)
addq $0x68, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movsd %xmm0, 0x30(%rsp)
movl 0x44(%rsp), %eax
shll %eax
subl $0x1, %eax
movl %eax, 0x2c(%rsp)
movslq 0x2c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x9660
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cvtsi2ssl 0x44(%rsp), %xmm0
cvtsi2ssl 0x3c(%rsp), %xmm2
movl 0x40(%rsp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm1
movss 0x453dd(%rip), %xmm3    # 0x591ec
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
cvtsi2ssl 0x44(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
xorl %eax, %eax
subl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x44(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x13f0a
cvtsi2ssl 0xc(%rsp), %xmm0
subss 0x14(%rsp), %xmm0
divss 0x10(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
cvtsi2ssl 0xc(%rsp), %xmm1
movaps 0x453a0(%rip), %xmm0    # 0x59220
pand %xmm0, %xmm1
cvtsi2ssl 0x44(%rsp), %xmm0
divss %xmm0, %xmm1
movss 0x452fa(%rip), %xmm0    # 0x59190
subss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
cmpl $0x0, 0x3c(%rsp)
jl 0x13ec7
movss 0x4533d(%rip), %xmm0    # 0x591ec
mulss 0x8(%rsp), %xmm0
mulss 0x8(%rsp), %xmm0
callq 0x91c0
movss %xmm0, (%rsp)
jmp 0x13ed6
movss 0x452c1(%rip), %xmm0    # 0x59190
movss %xmm0, (%rsp)
jmp 0x13ed6
movss 0x4(%rsp), %xmm0
movss (%rsp), %xmm1
mulss %xmm1, %xmm0
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x18(%rsp)
movss %xmm0, (%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x13e48
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rsp)
movl -0x10(%rsp), %eax
subl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
movl 0x24(%rcx), %ecx
subl $0x1, %ecx
movq -0x8(%rsp), %rdx
imull 0x2c(%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rsp)
movl -0x18(%rsp), %eax
subl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movl 0x28(%rcx), %ecx
subl $0x1, %ecx
movq -0x8(%rsp), %rdx
imull 0x30(%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rsp)
cmpl $0x0, -0x1c(%rsp)
jl 0x13fb6
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cltd
idivl 0x8(%rcx)
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x13fbe
xorl %eax, %eax
movl %eax, -0x2c(%rsp)
jmp 0x13fbe
movl -0x2c(%rsp), %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x20(%rsp)
jl 0x13fe3
movl -0x20(%rsp), %eax
movq -0x8(%rsp), %rcx
cltd
idivl 0xc(%rcx)
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0x13feb
xorl %eax, %eax
movl %eax, -0x30(%rsp)
jmp 0x13feb
movl -0x30(%rsp), %eax
movl %eax, -0x28(%rsp)
movl -0x24(%rsp), %ecx
imull -0x28(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rsp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rsp), %rax
imull 0x24(%rax), %ecx
movq -0x8(%rsp), %rax
imull 0x28(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x44(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x80, %edi
callq 0x9660
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl $0x5, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x5, 0xc(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x14(%rax)
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x10(%rsp), %ecx
subl $0x1, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x8(%rsp), %rax
movl $0x4, 0x24(%rax)
movq 0x8(%rsp), %rax
movl $0x4, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x8, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x5, 0x2c(%rax)
movq 0x8(%rsp), %rax
movl $0x5, 0x30(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x34(%rax)
movq 0x8(%rsp), %rax
movsd 0x44fdb(%rip), %xmm0    # 0x590e0
movsd %xmm0, 0x38(%rax)
movq 0x8(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rax), %rax
imulq %rax, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
movq 0x8(%rsp), %rax
movslq 0x4(%rax), %rax
imulq %rax, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x5c(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rdi
callq 0x9900
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movl 0x34(%rsp), %edi
movl 0x30(%rsp), %esi
callq 0x9ae0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x14270
movq (%rax), %rcx
movq %rcx, 0xc(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x14(%rsp)
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x14280
movq 0x20(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x142c0
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x14350
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x14326
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x1433e
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x14380
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x143a7
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1441f
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jge 0x14404
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x143f5
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9620
jmp 0x143f7
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x143bb
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x5c(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x58(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x60(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_alloc_buffers
static void
_vl_dsift_alloc_buffers (VlDsiftFilter* self)
{
  _vl_dsift_update_buffers (self) ;
  {
    int numFrameAlloc = vl_dsift_get_keypoint_num (self) ;
    int numBinAlloc   = vl_dsift_get_descriptor_size (self) ;
    int numGradAlloc  = self->geom.numBinT ;

    /* see if we need to update the buffers */
    if (numBinAlloc != self->numBinAlloc ||
        numGradAlloc != self->numGradAlloc ||
        numFrameAlloc != self->numFrameAlloc) {

      int t ;

      _vl_dsift_free_buffers(self) ;

      self->frames = vl_malloc(sizeof(VlDsiftKeypoint) * numFrameAlloc) ;
      self->descrs = vl_malloc(sizeof(float) * numBinAlloc * numFrameAlloc) ;
      self->grads  = vl_malloc(sizeof(float*) * numGradAlloc) ;
      for (t = 0 ; t < numGradAlloc ; ++t) {
        self->grads[t] =
          vl_malloc(sizeof(float) * self->imWidth * self->imHeight) ;
      }
      self->numBinAlloc = numBinAlloc ;
      self->numGradAlloc = numGradAlloc ;
      self->numFrameAlloc = numFrameAlloc ;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9900
movq 0x10(%rsp), %rdi
callq 0x15790
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x156b0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jne 0x14c19
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x60(%rcx), %eax
jne 0x14c19
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x5c(%rcx), %eax
je 0x14ceb
movq 0x10(%rsp), %rdi
callq 0x14350
movslq 0xc(%rsp), %rdi
shlq $0x5, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rax)
movslq 0x8(%rsp), %rdi
shlq $0x2, %rdi
movslq 0xc(%rsp), %rax
imulq %rax, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movslq 0x4(%rsp), %rdi
shlq $0x3, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x68(%rax)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x14cc7
movq 0x10(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rax), %rax
imulq %rax, %rdi
callq 0x9660
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rax
movslq (%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x14c81
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x58(%rax)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x60(%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x5c(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/mathop.h
// Function: vl_fast_atan2_f
VL_INLINE float
vl_fast_atan2_f (float y, float x)
{
  float angle, r ;
  float const c3 = 0.1821F ;
  float const c1 = 0.9675F ;
  float abs_y    = vl_abs_f (y) + VL_EPSILON_F ;

  if (x >= 0) {
    r = (x - abs_y) / (x + abs_y) ;
    angle = (float) (VL_PI / 4) ;
  } else {
    r = (x + abs_y) / (abs_y - x) ;
    angle = (float) (3 * VL_PI / 4) ;
  }
  angle += (c3*r*r - c1) * r ;
  return (y < 0) ? - angle : angle ;
}

// Assembly:
subq $0x28, %rsp
movss %xmm0, 0x24(%rsp)
movss %xmm1, 0x20(%rsp)
movss 0x444f8(%rip), %xmm0    # 0x59200
movss %xmm0, 0x14(%rsp)
movss 0x444e6(%rip), %xmm0    # 0x591fc
movss %xmm0, 0x10(%rsp)
movss 0x24(%rsp), %xmm0
callq 0x157a0
movss 0x444c9(%rip), %xmm1    # 0x591f8
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x14d79
movss 0x20(%rsp), %xmm0
subss 0xc(%rsp), %xmm0
movss 0x20(%rsp), %xmm1
addss 0xc(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x44497(%rip), %xmm0    # 0x59208
movss %xmm0, 0x1c(%rsp)
jmp 0x14da9
movss 0x20(%rsp), %xmm0
addss 0xc(%rsp), %xmm0
movss 0xc(%rsp), %xmm1
subss 0x20(%rsp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
movss 0x44461(%rip), %xmm0    # 0x59204
movss %xmm0, 0x1c(%rsp)
movss 0x4444f(%rip), %xmm0    # 0x59200
mulss 0x18(%rsp), %xmm0
movss 0x18(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x44443(%rip), %xmm1    # 0x5920c
addss %xmm1, %xmm0
movss 0x18(%rsp), %xmm2
movss 0x1c(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
xorps %xmm0, %xmm0
ucomiss 0x24(%rsp), %xmm0
jbe 0x14e0c
movss 0x1c(%rsp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x14e18
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/dsift.c
// Function: vl_dsift_normalize_histogram
VL_INLINE float
_vl_dsift_normalize_histogram (float * begin, float * end)
{
  float * iter ;
  float  norm = 0.0F ;

  for (iter = begin ; iter < end ; ++ iter) {
    norm += (*iter) * (*iter) ;
  }
  norm = vl_fast_sqrt_f (norm) + VL_EPSILON_F ;

  for (iter = begin; iter < end ; ++ iter) {
    *iter /= norm ;
  }
  return norm ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x15723
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
movq 0x10(%rsp), %rax
movss (%rax), %xmm2
movss 0xc(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0x156e1
movss 0xc(%rsp), %xmm0
callq 0x14e30
movss 0x43ac2(%rip), %xmm1    # 0x591f8
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x1577d
movss 0xc(%rsp), %xmm1
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
movq 0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
jmp 0x1574a
movss 0xc(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/mathop.h
// Function: vl_fast_resqrt_f
VL_INLINE float
vl_fast_resqrt_f (float x)
{
  /* 32-bit version */
  union {
    float x ;
    vl_int32  i ;
  } u ;

  float xhalf = (float) 0.5 * x ;

  /* convert floating point value in RAW integer */
  u.x = x ;

  /* gives initial guess y0 */
  u.i = 0x5f3759df - (u.i >> 1);
  /*u.i = 0xdf59375f - (u.i>>1);*/

  /* two Newton steps */
  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
  u.x = u.x * ( (float) 1.5  - xhalf*u.x*u.x) ;
  return u.x ;
}

// Assembly:
movss %xmm0, -0x4(%rsp)
movss 0x43a22(%rip), %xmm0    # 0x591f0
mulss -0x4(%rsp), %xmm0
movss %xmm0, -0xc(%rsp)
movss -0x4(%rsp), %xmm0
movss %xmm0, -0x8(%rsp)
movl -0x8(%rsp), %ecx
sarl %ecx
movl $0x5f3759df, %eax       # imm = 0x5F3759DF
subl %ecx, %eax
movl %eax, -0x8(%rsp)
movss -0x8(%rsp), %xmm0
movss -0xc(%rsp), %xmm1
mulss -0x8(%rsp), %xmm1
movss -0x8(%rsp), %xmm2
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm1
movss 0x439ec(%rip), %xmm2    # 0x59214
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x8(%rsp)
movss -0x8(%rsp), %xmm0
movss -0xc(%rsp), %xmm1
mulss -0x8(%rsp), %xmm1
movss -0x8(%rsp), %xmm2
movd %xmm1, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm1
mulss %xmm2, %xmm1
movss 0x439ad(%rip), %xmm2    # 0x59214
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x8(%rsp)
movss -0x8(%rsp), %xmm0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movsd %xmm0, 0x20(%rsp)
cvtsi2ssl 0x34(%rsp), %xmm0
cvtsi2ssl 0x2c(%rsp), %xmm2
movl 0x30(%rsp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm1
movss 0x43937(%rip), %xmm3    # 0x591ec
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
cvtsi2ssl 0x34(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
cvtsd2ss %xmm1, %xmm1
mulss %xmm1, %xmm0
movss %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
xorl %eax, %eax
subl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x34(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x15975
cvtsi2ssl 0x14(%rsp), %xmm0
subss 0x1c(%rsp), %xmm0
divss 0x18(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
cmpl $0x0, 0x2c(%rsp)
jl 0x15946
movss 0x438bf(%rip), %xmm0    # 0x591ec
mulss 0xc(%rsp), %xmm0
mulss 0xc(%rsp), %xmm0
callq 0x91c0
movss %xmm0, 0x8(%rsp)
jmp 0x15956
movss 0x43842(%rip), %xmm0    # 0x59190
movss %xmm0, 0x8(%rsp)
jmp 0x15956
movss 0x8(%rsp), %xmm0
addss 0x10(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x158f7
movl 0x34(%rsp), %eax
shll %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm1
movss 0x10(%rsp), %xmm0
divss %xmm1, %xmm0
movss %xmm0, 0x10(%rsp)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/fisher.c
// Function: vl_fisher_encode
VL_EXPORT vl_size
vl_fisher_encode
(void * enc, vl_type dataType,
 void const * means, vl_size dimension, vl_size numClusters,
 void const * covariances,
 void const * priors,
 void const * data,  vl_size numData,
 int flags
)
{
  switch(dataType) {
    case VL_TYPE_FLOAT:
      return _vl_fisher_encode_f
      ((float *) enc,
       (float const *) means, dimension, numClusters,
       (float const *) covariances,
       (float const *) priors,
       (float const *) data, numData,
       flags);
    case VL_TYPE_DOUBLE:
      return _vl_fisher_encode_d
      ((double *) enc,
       (double const *) means, dimension, numClusters,
       (double const *) covariances,
       (double const *) priors,
       (double const *) data, numData,
       flags);
      break;
    default:
      abort();
  }
}

// Assembly:
subq $0x58, %rsp
movl 0x78(%rsp), %eax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0x159f1
jmp 0x159e3
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0x15a36
jmp 0x15a7b
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x68(%rsp), %r11
movq 0x70(%rsp), %r10
movl 0x78(%rsp), %eax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x15a90
movq %rax, 0x50(%rsp)
jmp 0x15a80
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x60(%rsp), %r9
movq 0x68(%rsp), %r11
movq 0x70(%rsp), %r10
movl 0x78(%rsp), %eax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x164b0
movq %rax, 0x50(%rsp)
jmp 0x15a80
callq 0x90b0
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq $0x0, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movb $0x0, %al
callq 0x9430
movq %rax, 0x40(%rsp)
callq 0x176e0
movq %rax, %rdi
addq $0x98, %rdi
callq 0x22ea0
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x1701f
cmpl $0x0, 0x4c(%rsp)
jle 0x16fa4
movslq 0x4c(%rsp), %rdi
shlq $0x0, %rdi
callq 0x9660
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x16fa2
jmp 0x1701f
jmp 0x16fa4
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x97a0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x9b00
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %rax, %r9
movq 0x38(%rsp), %r10
leaq 0x42273(%rip), %rdx     # 0x59267
leaq 0x422b7(%rip), %rax     # 0x592b2
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x9410
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x16f72
cmpq $0x0, 0x40(%rsp)
je 0x17031
movq 0x40(%rsp), %rdi
callq 0x9620
cmpq $0x0, 0x38(%rsp)
je 0x17043
movq 0x38(%rsp), %rdi
callq 0x9620
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xe8, %rsp
testb %al, %al
je 0x1716c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %edi, 0xe4(%rsp)
movq %rsi, 0xd8(%rsp)
callq 0x17230
movq %rax, 0xd0(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xf0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpq $0x0, 0xd8(%rsp)
je 0x171f7
movq 0xd0(%rsp), %rdi
addq $0x4, %rdi
movq 0xd8(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x9200
jmp 0x17203
movq 0xd0(%rsp), %rax
movb $0x0, 0x4(%rax)
movl 0xe4(%rsp), %ecx
movq 0xd0(%rsp), %rax
movl %ecx, (%rax)
movl 0xe4(%rsp), %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
callq 0x17320
callq 0x176e0
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
callq 0x173e0
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
callq 0x176e0
movq %rax, 0x10(%rsp)
callq 0x9910
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x9bf0
movq 0x10(%rsp), %rax
cmpq $0x1, 0x68(%rax)
jb 0x1737d
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x98f0
cmpl $0x0, %eax
je 0x1737d
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x68(%rax)
jmp 0x173bf
jmp 0x1737f
movq 0x10(%rsp), %rax
cmpq $0x1, 0x68(%rax)
jb 0x173a4
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0x92a0
jmp 0x1737f
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
movq $0x1, 0x68(%rax)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x9710
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/generic.c
// Function: vl_unlock_state
static void
vl_unlock_state (void)
{
#if ! defined(VL_DISABLE_THREADS)
#if   defined(VL_THREADS_POSIX)
  VlState * state = vl_get_state () ;
  pthread_mutex_lock (&state->mutex) ;
  -- state->mutexCount ;
  if (state->mutexCount == 0) {
    pthread_cond_signal (&state->mutexCondition) ;
  }
  pthread_mutex_unlock (&state->mutex) ;
#elif defined(VL_THREADS_WIN)
  LeaveCriticalSection (&vl_get_state()->mutex) ;
#endif
#endif
}

// Assembly:
pushq %rax
callq 0x176e0
movq %rax, (%rsp)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x9bf0
movq (%rsp), %rax
movq 0x68(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x68(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x1741f
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x9550
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x9710
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x34(%rsp), %edi
callq 0x18080
movq %rax, 0x10(%rsp)
movl $0x1, %edi
movl $0x80, %esi
callq 0x9a70
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x60(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x32, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x1, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x78(%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9a70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rdi
imulq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9a70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rdi
imulq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x9a70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x28(%rsp), %rdi
movl $0x8, %esi
callq 0x9a70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl %ecx, %ecx
cmpq %rcx, %rax
jge 0x18075
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rax
movq 0x18(%rsp), %rcx
movsd 0x412e0(%rip), %xmm0    # 0x59340
movsd %xmm0, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x18035
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x18145
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x1817e
movq (%rsp), %rax
cmpl $0x0, 0x78(%rax)
je 0x1817e
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x9290
movq (%rsp), %rax
movq $0x0, 0x68(%rax)
movq (%rsp), %rax
movl $0x0, 0x78(%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1819d
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x181b5
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x181cd
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x181e5
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x18207
movq (%rsp), %rax
cmpl $0x0, 0x78(%rax)
je 0x18207
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x9290
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x183b3
movq 0x10(%rsp), %rax
cmpl $0x0, 0x78(%rax)
je 0x183b3
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x9290
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x78(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x18080
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %edi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x9850
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movl 0x60(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x60(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x30(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x30(%rax)
movq 0x10(%rsp), %rax
movsd 0x70(%rax), %xmm0
movq (%rsp), %rax
movsd %xmm0, 0x70(%rax)
movq (%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
imulq 0x10(%rax), %rdx
movq 0x10(%rsp), %rax
imulq 0x8(%rax), %rdx
callq 0x9640
movq (%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
imulq 0x10(%rax), %rdx
movq 0x10(%rsp), %rax
imulq 0x8(%rax), %rdx
callq 0x9640
movq (%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
imulq 0x10(%rax), %rdx
callq 0x9640
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_init_with_rand_data
void
vl_gmm_init_with_rand_data
(VlGMM * self,
 void const * data,
 vl_size numData)
{
  vl_gmm_reset (self) ;
  switch (self->dataType) {
    case VL_TYPE_FLOAT : _vl_gmm_init_with_rand_data_f (self, (float const *)data, numData) ; break ;
    case VL_TYPE_DOUBLE : _vl_gmm_init_with_rand_data_d (self, (double const *)data, numData) ; break ;
    default:
      abort() ;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x96e0
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x190ea
jmp 0x190df
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x19100
jmp 0x19116
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x19120
jmp 0x1911b
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x19300
jmp 0x1911b
callq 0x90b0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_init_with_kmeans
void
vl_gmm_init_with_kmeans
(VlGMM * self,
 void const * data,
 vl_size numData,
 VlKMeans * kmeansInit)
{
  vl_gmm_reset (self) ;
  switch (self->dataType) {
    case VL_TYPE_FLOAT :
      _vl_gmm_init_with_kmeans_f
      (self, (float const *)data, numData, kmeansInit) ;
      break ;
    case VL_TYPE_DOUBLE :
      _vl_gmm_init_with_kmeans_d
      (self, (double const *)data, numData, kmeansInit) ;
      break ;
    default:
      abort() ;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x96e0
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x1951f
jmp 0x19514
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x1953a
jmp 0x19555
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x19560
jmp 0x1955a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x19840
jmp 0x1955a
callq 0x90b0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/gmm.c
// Function: vl_gmm_em
double vl_gmm_em (VlGMM * self, void const * data, vl_size numData)
{
  switch (self->dataType) {
    case VL_TYPE_FLOAT:
      return _vl_gmm_em_f (self, (float const *)data, numData) ; break ;
    case VL_TYPE_DOUBLE:
      return _vl_gmm_em_d (self, (double const *)data, numData) ; break ;
    default:
      abort() ;
  }
  return 0 ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x19f80
jmp 0x19f75
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x19f9c
jmp 0x19fb8
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x19fd0
movsd %xmm0, 0x20(%rsp)
jmp 0x19fbd
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1a2c0
movsd %xmm0, 0x20(%rsp)
jmp 0x19fbd
callq 0x90b0
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x8(%rsp), %rax
jae 0x1a73c
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x18080
movq %rax, %rdi
imulq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
imulq 0x10(%rax), %rdi
callq 0x9660
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1b8cf
movl $0x0, 0x4(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1b8a5
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
imulq 0x8(%rdx), %rcx
addq 0x28(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm1
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1b890
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rdx
imulq 0x8(%rdx), %rcx
addq 0x28(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl $0x1, 0x4(%rsp)
jmp 0x1b892
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1b80c
cmpl $0x0, 0x4(%rsp)
je 0x1b8ba
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1b8bc
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1b7e7
cmpq $0x0, 0x18(%rsp)
jbe 0x1b903
movq 0x30(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jle 0x1b903
callq 0x91a0
movq %rax, %rcx
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x3dbaa(%rip), %rdi     # 0x594a9
movb $0x0, %al
callq *%rcx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq %r9, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x1db33
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x24(%rsp), %eax
jne 0x1db21
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1db23
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1daf4
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
shlq $0x0, %rdi
imulq 0x8(%rsp), %rdi
callq 0x9660
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x1dbdc
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x24(%rsp), %eax
jne 0x1dbca
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
imulq 0x28(%rsp), %rax
addq %rax, %rdi
movq 0x40(%rsp), %rsi
movq 0x10(%rsp), %rax
imulq 0x28(%rsp), %rax
addq %rax, %rsi
movq 0x28(%rsp), %rdx
shlq $0x0, %rdx
callq 0x9640
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1dbcc
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1db6a
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)