LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/random.h
// Function: vl_rand_uindex
VL_INLINE vl_uindex
vl_rand_uindex (VlRand * self, vl_uindex range)
{
  if (range <= 0xffffffff) {
    /* 32-bit version */
    return (vl_rand_uint32 (self) % (vl_uint32)range) ;
  } else {
    /* 64-bit version */
    return (vl_rand_uint64 (self) % range) ;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %r12
shrq $0x20, %r12
callq 0x9360
movl %eax, %r14d
testq %r12, %r12
jne 0x1f4fe
movl %r14d, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
jmp 0x1f51a
movq %r15, %rdi
callq 0x9360
movl %eax, %eax
shlq $0x20, %r14
orq %rax, %r14
movq %r14, %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/kmeans.c
// Function: vl_kmeans_sort_data_helper_f
static void
VL_XCAT(_vl_kmeans_sort_data_helper_, SFX)
(VlKMeans * self, vl_uint32 * permutations, TYPE const * data, vl_size numData)
{
  vl_uindex d, x ;

  for (d = 0 ; d < self->dimension ; ++d) {
    VlKMeansSortWrapper array ;
    array.permutation = permutations + d * numData ;
    array.data = data + d ;
    array.stride = self->dimension ;
    for (x = 0 ; x < numData ; ++x) {
      array.permutation[x] = (vl_uint32)x ;
    }
    VL_XCAT3(_vl_kmeans_, SFX, _qsort_sort)(&array, numData) ;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r12
leaq -0x1(%rcx), %rax
movq %rax, (%rsp)
leaq (,%rcx,4), %rbp
xorl %r14d, %r14d
movq %rsi, %r15
movq 0x8(%r12), %rax
cmpq %rax, %r14
jae 0x1f5cb
movq %r14, %rcx
imulq %rbx, %rcx
leaq (,%rcx,4), %rcx
addq %r13, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rsp), %rcx
leaq (%rcx,%r14,4), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq %rax, %rbx
je 0x1f5b3
movl %eax, (%r15,%rax,4)
incq %rax
jmp 0x1f5a5
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x1f5da
incq %r14
addq %rbp, %r15
jmp 0x1f56f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/qsort-def.h
// Function: vl_kmeans_f_qsort_sort_recursive
VL_INLINE void
VL_QSORT_sort_recursive
(VL_QSORT_array array, vl_uindex begin, vl_uindex end)
{
  vl_uindex pivot = (end + begin) / 2 ;
  vl_uindex lowPart, i ;

  assert (begin <= end) ;

  /* swap pivot with last */
  VL_QSORT_swap (array, pivot, end) ;
  pivot = end ;

  /*
   Now scan from left to right, moving all element smaller
   or equal than the pivot to the low part
   array[0], array[1], ..., array[lowPart - 1].
   */
  lowPart = begin ;
  for (i = begin; i < end ; ++i) { /* one less */
    if (VL_QSORT_cmp (array, i, pivot) <= 0) {
      /* array[i] must be moved into the low part */
      VL_QSORT_swap (array, lowPart, i) ;
      lowPart ++ ;
    }
  }

  /* the pivot should also go into the low part */
  VL_QSORT_swap (array, lowPart, pivot) ;
  pivot = lowPart ;

  /* do recursion */
  if (pivot > begin) {
    /* note that pivot-1 stays non-negative */
    VL_QSORT_sort_recursive (array, begin, pivot - 1) ;
  }
  if (pivot < end) {
    VL_QSORT_sort_recursive (array, pivot + 1, end) ;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rax
xorps %xmm1, %xmm1
leaq (%rsi,%rbx), %rcx
andq $-0x2, %rcx
movl (%rax,%rcx,2), %edx
movl (%rax,%rbx,4), %edi
movl %edi, (%rax,%rcx,2)
movl %edx, (%rax,%rbx,4)
movq %rsi, %r15
movq %rsi, %rcx
cmpq %rbx, %rcx
jae 0x1f645
movl (%rax,%rcx,4), %edx
movq 0x8(%r14), %rdi
movq 0x10(%r14), %r8
movl (%rax,%rbx,4), %r9d
imulq %r8, %r9
imulq %rdx, %r8
movss (%rdi,%r8,4), %xmm0
subss (%rdi,%r9,4), %xmm0
ucomiss %xmm0, %xmm1
jb 0x1f640
movl (%rax,%r15,4), %edi
movl %edx, (%rax,%r15,4)
movl %edi, (%rax,%rcx,4)
incq %r15
incq %rcx
jmp 0x1f605
movl (%rax,%r15,4), %ecx
movl (%rax,%rbx,4), %edx
movl %edx, (%rax,%r15,4)
movl %ecx, (%rax,%rbx,4)
cmpq %rsi, %r15
jbe 0x1f66a
leaq -0x1(%r15), %rdx
movq %r14, %rdi
callq 0x1f5da
xorps %xmm1, %xmm1
movq (%r14), %rax
leaq 0x1(%r15), %rsi
cmpq %rbx, %r15
jb 0x1f5eb
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/kmeans.c
// Function: vl_kmeans_update_center_distances_f
static double
VL_XCAT(_vl_kmeans_update_center_distances_, SFX)
(VlKMeans * self)
{
#if (FLT == VL_TYPE_FLOAT)
  VlFloatVectorComparisonFunction distFn = vl_get_vector_comparison_function_f(self->distance) ;
#else
  VlDoubleVectorComparisonFunction distFn = vl_get_vector_comparison_function_d(self->distance) ;
#endif

  if (! self->centerDistances) {
    self->centerDistances = vl_malloc (sizeof(TYPE) *
                                       self->numCenters *
                                       self->numCenters) ;
  }
  VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)(self->centerDistances,
      self->dimension,
      self->centers, self->numCenters,
      NULL, 0,
      distFn) ;
  return self->numCenters * (self->numCenters - 1) / 2 ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x30(%rdi), %edi
callq 0x9830
movq %rax, %r14
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
jne 0x1f6b0
movq 0x10(%rbx), %rdi
imulq %rdi, %rdi
shlq $0x2, %rdi
callq 0x95e0
movq %rax, %rdi
movq %rax, 0x60(%rbx)
movq 0x58(%rbx), %rdx
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rcx
movq %r14, (%rsp)
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x9af0
movq 0x10(%rbx), %rax
leaq -0x1(%rax), %rcx
imulq %rax, %rcx
shrq %rcx
cvtsi2sd %rcx, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/lbp.c
// Function: vl_lbp_new
VlLbp *
vl_lbp_new(VlLbpMappingType type, vl_bool transposed)
{
  VlLbp * self = vl_malloc(sizeof(VlLbp)) ;
  if (self == NULL) {
    vl_set_last_error(VL_ERR_ALLOC, NULL) ;
    return NULL ;
  }
  self->transposed = transposed ;
  switch (type) {
    case VlLbpUniform: _vl_lbp_init_uniform(self) ; break ;
    default: exit(1) ;
  }
  return self ;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebp
movl $0x110, %edi            # imm = 0x110
callq 0x95e0
movq %rax, %rbx
testq %rax, %rax
je 0x1f94b
movl %r14d, 0x108(%rbx)
testl %ebp, %ebp
jne 0x1f95f
movq $0x3a, (%rbx)
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x1f8dd
movb $0x39, 0x8(%rbx,%rax)
incq %rax
jmp 0x1f8cb
movb $0x38, %al
movb %al, 0x8(%rbx)
movb %al, 0x107(%rbx)
xorl %edx, %edx
pushq $0x2
popq %rsi
pushq $0x1
popq %rdi
pushq $-0x1
popq %r8
xorl %r9d, %r9d
cmpl $0x8, %r9d
je 0x1f957
movl %edx, %r10d
movl %esi, %r11d
movl %edi, %eax
cmpl $0x8, %eax
je 0x1f941
movl %r8d, %ebp
movl %eax, %ecx
shll %cl, %ebp
movl %r11d, %ecx
andb $0x7, %cl
cmpl $0x0, 0x108(%rbx)
notl %ebp
movzbl %cl, %ecx
cmovel %r9d, %ecx
shll %cl, %ebp
movzbl %bpl, %ecx
shrl $0x8, %ebp
orl %ebp, %ecx
movb %r10b, 0x8(%rbx,%rcx)
incl %eax
decl %r11d
incb %r10b
jmp 0x1f905
incl %r9d
decl %esi
addb $0x7, %dl
jmp 0x1f8f7
pushq $0x2
popq %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x9150
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x9990
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/liop.c
// Function: vl_liopdesc_delete
void
vl_liopdesc_delete (VlLiopDesc * self)
{
  vl_free (self->patchPixels) ;
  vl_free (self->patchIntensities) ;
  vl_free (self->patchPermutation) ;
  vl_free (self->neighPermutation) ;
  vl_free (self->neighIntensities) ;
  vl_free (self->neighSamplesX) ;
  vl_free (self->neighSamplesY) ;
  vl_free (self) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x95b0
movq 0x30(%rbx), %rdi
callq 0x95b0
movq 0x38(%rbx), %rdi
callq 0x95b0
movq 0x50(%rbx), %rdi
callq 0x95b0
movq 0x48(%rbx), %rdi
callq 0x95b0
movq 0x58(%rbx), %rdi
callq 0x95b0
movq 0x60(%rbx), %rdi
callq 0x95b0
movq %rbx, %rdi
popq %rbx
jmp 0x95b0
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_distance_l2_f
VL_EXPORT T
VL_XCAT(_vl_distance_l2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T d = *X++ - *Y++ ;
    acc += d * d ;
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
xorps %xmm0, %xmm0
cmpq %rax, %rsi
jae 0x206f6
movss (%rsi), %xmm1
subss (%rdx), %xmm1
addq $0x4, %rsi
addq $0x4, %rdx
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
jmp 0x206d7
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_distance_l1_f
VL_EXPORT T
VL_XCAT(_vl_distance_l1_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T d = *X++ - *Y++ ;
    acc += VL_MAX(d, -d) ;
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
xorps %xmm0, %xmm0
movaps 0xcc6b(%rip), %xmm1     # 0x2d370
cmpq %rax, %rsi
jae 0x2072a
movss (%rsi), %xmm2
addq $0x4, %rsi
subss (%rdx), %xmm2
addq $0x4, %rdx
movaps %xmm2, %xmm3
xorps %xmm1, %xmm3
maxss %xmm3, %xmm2
addss %xmm2, %xmm0
jmp 0x20705
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_distance_chi2_f
VL_EXPORT T
VL_XCAT(_vl_distance_chi2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T delta = a - b ;
    T denom = (a + b) ;
    T numer = delta * delta ;
    if (denom) {
      T ratio = numer / denom ;
      acc += ratio ;
    }
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
cmpq %rax, %rsi
jae 0x20774
movss (%rsi), %xmm2
addq $0x4, %rsi
movss (%rdx), %xmm3
addq $0x4, %rdx
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
subss %xmm3, %xmm2
mulss %xmm2, %xmm2
divss %xmm4, %xmm2
addss %xmm0, %xmm2
cmpneqss %xmm1, %xmm4
andps %xmm4, %xmm2
andnps %xmm0, %xmm4
orps %xmm2, %xmm4
movaps %xmm4, %xmm0
jmp 0x20735
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_distance_hellinger_f
VL_EXPORT T
VL_XCAT(_vl_distance_hellinger_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
#if (FLT == VL_TYPE_FLOAT)
    acc += a + b - 2.0 * sqrtf (a*b) ;
#else
    acc += a + b - 2.0 * sqrt (a*b) ;
#endif
  }
  return acc ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq (%rsi,%rdi,4), %r15
xorps %xmm2, %xmm2
xorps %xmm3, %xmm3
cmpq %r15, %r14
jae 0x20804
movss (%r14), %xmm1
movss (%rbx), %xmm4
movaps %xmm1, %xmm0
mulss %xmm4, %xmm0
ucomiss %xmm2, %xmm0
jb 0x207ae
sqrtss %xmm0, %xmm0
jmp 0x207da
movss %xmm3, 0xc(%rsp)
movss %xmm1, 0x8(%rsp)
movss %xmm4, 0x4(%rsp)
callq 0x9610
movss 0x4(%rsp), %xmm4
movss 0x8(%rsp), %xmm1
movss 0xc(%rsp), %xmm3
xorps %xmm2, %xmm2
addq $0x4, %r14
addq $0x4, %rbx
addss %xmm4, %xmm1
cvtss2sd %xmm1, %xmm1
cvtss2sd %xmm0, %xmm0
addsd %xmm0, %xmm0
subsd %xmm0, %xmm1
cvtss2sd %xmm3, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm3
jmp 0x2078e
movaps %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_distance_js_f
VL_EXPORT T
VL_XCAT(_vl_distance_js_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T x = *X++ ;
    T y = *Y++ ;
    if (x) acc += x - x * VL_XCAT(vl_log2_,SFX)(1 + y/x) ;
    if (y) acc += y - y * VL_XCAT(vl_log2_,SFX)(1 + x/y) ;
  }
  return acc ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq (%rsi,%rdi,4), %r15
xorps %xmm0, %xmm0
cmpq %r15, %r14
jae 0x208d5
movss (%r14), %xmm2
movss (%rbx), %xmm1
ucomiss 0xd170(%rip), %xmm2     # 0x2d9b0
movss %xmm1, 0x8(%rsp)
jne 0x2084a
jnp 0x2088b
movss %xmm0, 0x4(%rsp)
movaps %xmm1, %xmm0
divss %xmm2, %xmm0
addss 0xcac5(%rip), %xmm0     # 0x2d324
movss %xmm2, 0xc(%rsp)
callq 0x9b40
movss 0xc(%rsp), %xmm2
mulss %xmm2, %xmm0
movaps %xmm2, %xmm1
subss %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
addss %xmm1, %xmm0
movss 0x8(%rsp), %xmm1
addq $0x4, %r14
addq $0x4, %rbx
ucomiss 0xd116(%rip), %xmm1     # 0x2d9b0
jne 0x2089e
jnp 0x20827
divss %xmm1, %xmm2
addss 0xca7a(%rip), %xmm2     # 0x2d324
movss %xmm0, 0x4(%rsp)
movaps %xmm2, %xmm0
callq 0x9b40
movss 0x8(%rsp), %xmm1
mulss %xmm1, %xmm0
subss %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
addss %xmm1, %xmm0
jmp 0x20827
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_kernel_l1_f
VL_EXPORT T
VL_XCAT(_vl_kernel_l1_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T a_ = VL_XCAT(vl_abs_, SFX) (a) ;
    T b_ = VL_XCAT(vl_abs_, SFX) (b) ;
    acc += a_ + b_ - VL_XCAT(vl_abs_, SFX) (a - b) ;
  }
  return acc / ((T)2) ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
xorps %xmm0, %xmm0
movaps 0xc840(%rip), %xmm1     # 0x2d150
cmpq %rax, %rsi
jae 0x20943
movss (%rsi), %xmm2
addq $0x4, %rsi
movss (%rdx), %xmm3
addq $0x4, %rdx
movaps %xmm2, %xmm4
andps %xmm1, %xmm4
subss %xmm3, %xmm2
andps %xmm1, %xmm3
addss %xmm4, %xmm3
andps %xmm1, %xmm2
subss %xmm2, %xmm3
addss %xmm3, %xmm0
jmp 0x20910
mulss 0xc9dd(%rip), %xmm0     # 0x2d328
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_kernel_chi2_f
VL_EXPORT T
VL_XCAT(_vl_kernel_chi2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T denom = (a + b) ;
    if (denom) {
      T numer = 2 * a * b ;
      T ratio = numer / denom ;
      acc += ratio ;
    }
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
cmpq %rax, %rsi
jae 0x20995
movss (%rsi), %xmm2
addq $0x4, %rsi
movss (%rdx), %xmm3
addq $0x4, %rdx
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
addss %xmm2, %xmm2
mulss %xmm3, %xmm2
divss %xmm4, %xmm2
addss %xmm0, %xmm2
cmpneqss %xmm1, %xmm4
andps %xmm4, %xmm2
andnps %xmm0, %xmm4
orps %xmm2, %xmm4
movaps %xmm4, %xmm0
jmp 0x20956
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_kernel_hellinger_f
VL_EXPORT T
VL_XCAT(_vl_kernel_hellinger_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
#if (FLT == VL_TYPE_FLOAT)
    acc += sqrtf (a*b) ;
#else
    acc += sqrt (a*b) ;
#endif
  }
  return acc ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq (%rsi,%rdi,4), %r15
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
cmpq %r15, %r14
jae 0x209ea
movss (%r14), %xmm0
mulss (%rbx), %xmm0
ucomiss %xmm2, %xmm0
jb 0x209c8
sqrtss %xmm0, %xmm0
jmp 0x209dc
movss %xmm1, 0xc(%rsp)
callq 0x9610
xorps %xmm2, %xmm2
movss 0xc(%rsp), %xmm1
addq $0x4, %r14
addq $0x4, %rbx
addss %xmm0, %xmm1
jmp 0x209af
movaps %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_kernel_js_f
VL_EXPORT T
VL_XCAT(_vl_kernel_js_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T x = *X++ ;
    T y = *Y++ ;
    if (x) acc += x * VL_XCAT(vl_log2_,SFX)(1 + y/x) ;
    if (y) acc += y * VL_XCAT(vl_log2_,SFX)(1 + x/y) ;
  }
  return (T)0.5 * acc ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq (%rsi,%rdi,4), %r15
xorps %xmm0, %xmm0
cmpq %r15, %r14
jae 0x20ac4
movss (%r14), %xmm2
movss (%rbx), %xmm1
ucomiss 0xcf8a(%rip), %xmm2     # 0x2d9b0
movss %xmm1, 0x8(%rsp)
jne 0x20a30
jnp 0x20a76
movss %xmm0, 0x4(%rsp)
movaps %xmm1, %xmm0
divss %xmm2, %xmm0
addss 0xc8df(%rip), %xmm0     # 0x2d324
movss %xmm2, 0xc(%rsp)
callq 0x9b40
movss 0xc(%rsp), %xmm2
mulss %xmm2, %xmm0
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x8(%rsp), %xmm1
movss 0x4(%rsp), %xmm0
addq $0x4, %r14
addq $0x4, %rbx
ucomiss 0xcf2b(%rip), %xmm1     # 0x2d9b0
jne 0x20a89
jnp 0x20a0d
divss %xmm1, %xmm2
addss 0xc88f(%rip), %xmm2     # 0x2d324
movss %xmm0, 0x4(%rsp)
movaps %xmm2, %xmm0
callq 0x9b40
mulss 0x8(%rsp), %xmm0
movss 0x4(%rsp), %xmm1
addss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x4(%rsp), %xmm0
jmp 0x20a0d
mulss 0xc85c(%rip), %xmm0     # 0x2d328
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_distance_mahalanobis_sq_f
VL_EXPORT T
VL_XCAT(_vl_distance_mahalanobis_sq_, SFX)
(vl_size dimension, T const * X, T const * MU, T const * S)
{
  T const * X_end = X + dimension ;
  T acc = 0.0 ;
  while (X < X_end) {
    T d = *X++ - *MU++ ;
    acc += d * d * (*S++) ;
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
xorps %xmm0, %xmm0
xorl %edi, %edi
leaq (%rsi,%rdi), %r8
cmpq %rax, %r8
jae 0x20b05
movss (%r8), %xmm1
subss (%rdx,%rdi), %xmm1
mulss %xmm1, %xmm1
mulss (%rcx,%rdi), %xmm1
addss %xmm1, %xmm0
addq $0x4, %rdi
jmp 0x20adf
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_eval_vector_comparison_on_all_pairs_f
VL_EXPORT void
VL_XCAT(vl_eval_vector_comparison_on_all_pairs_, SFX)
(T * result, vl_size dimension,
 T const * X, vl_size numDataX,
 T const * Y, vl_size numDataY,
 COMPARISONFUNCTION_TYPE function)
{
  vl_uindex xi ;
  vl_uindex yi ;

  if (dimension == 0) return ;
  if (numDataX == 0) return ;
  assert (X) ;

  if (Y) {
    if (numDataY == 0) return ;
    for (yi = 0 ; yi < numDataY ; ++ yi) {
      for (xi = 0 ; xi < numDataX ; ++ xi) {
        *result++ = (*function)(dimension, X, Y) ;
        X += dimension ;
      }
      X -= dimension * numDataX ;
      Y += dimension ;
    }
  } else {
    T * resultTransp = result ;
    Y = X ;
    for (yi = 0 ; yi < numDataX ; ++ yi) {
      for (xi = 0 ; xi <= yi ; ++ xi) {
        T z = (*function)(dimension, X, Y) ;
        X += dimension ;
        *result       = z ;
        *resultTransp = z ;
        result        += 1 ;
        resultTransp  += numDataX ;
      }
      X -= dimension * (yi + 1) ;
      Y += dimension ;
      result       += numDataX - (yi + 1) ;
      resultTransp += 1        - (yi + 1) * numDataX ;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
sete %al
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
sete %cl
orb %al, %cl
je 0x20c14
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rbp
movq %rdx, %r14
movq %rdi, %r12
testq %r8, %r8
je 0x20c95
cmpq $0x0, 0x8(%rsp)
je 0x20c05
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
imulq %rax, %rcx
shlq $0x2, %rcx
negq %rcx
movq %rcx, 0x20(%rsp)
leaq (,%rax,4), %r13
xorl %ebx, %ebx
cmpq 0x8(%rsp), %rbx
je 0x20c05
movq 0x18(%rsp), %r15
subq $0x1, %r15
jb 0x20c81
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq *0x80(%rsp)
movss %xmm0, (%r12)
addq $0x4, %r12
addq %r13, %r14
jmp 0x20c5a
addq 0x20(%rsp), %r14
movq 0x10(%rsp), %rax
leaq (%rbp,%rax,4), %rbp
incq %rbx
jmp 0x20c4e
movq 0x10(%rsp), %rax
leaq (,%rax,4), %rax
movq %rax, 0x20(%rsp)
movq %rax, %rcx
negq %rcx
movq 0x18(%rsp), %rax
leaq (,%rax,4), %rdx
pushq $0x4
popq %rsi
movq %rdx, 0x28(%rsp)
subq %rdx, %rsi
leaq -0x4(,%rax,4), %rax
xorl %ebp, %ebp
movq %r14, %r13
movq %r12, 0x8(%rsp)
cmpq 0x18(%rsp), %rbp
je 0x20c05
movq %rsi, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rcx
leaq (%rcx,%rax), %rbx
xorl %r15d, %r15d
cmpq %rbp, %r15
ja 0x20d38
movq 0x10(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq *0x80(%rsp)
movq 0x8(%rsp), %rax
movss %xmm0, (%rax,%r15,4)
movss %xmm0, (%r12)
incq %r15
addq 0x20(%rsp), %r13
addq 0x28(%rsp), %r12
addq $0x4, %rbx
jmp 0x20cfd
incq %rbp
movq 0x40(%rsp), %rcx
addq %rcx, %r13
movq 0x10(%rsp), %rax
leaq (%r14,%rax,4), %r14
subq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rsi
addq %rsi, %r12
subq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
addq $-0x4, %rax
movq %rbx, 0x8(%rsp)
jmp 0x20cd7
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_svd2
void
vl_svd2 (double* S, double *U, double *V, double const *M)
{
  double m11 = M[0] ;
  double m21 = M[1] ;
  double m12 = M[2] ;
  double m22 = M[3] ;
  double cu1 = m11 ;
  double su1 = m21 ;
  double norm = sqrt(cu1*cu1 + su1*su1) ;
  double cu2, su2, cv2, sv2 ;
  double f, g, h ;
  double smin, smax ;
  cu1 /= norm ;
  su1 /= norm ;

  f = cu1 * m11 + su1 * m21 ;
  g = cu1 * m12 + su1 * m22 ;
  h = - su1 * m12 + cu1 * m22 ;

  vl_lapack_dlasv2 (&smin, &smax,
                    &sv2, &cv2,
                    &su2, &cu2,
                    f, g, h) ;

  assert(S) ;
  S[0] = smax ;
  S[1] = 0 ;
  S[2] = 0 ;
  S[3] = smin ;

  if (U) {
    U[0] = cu2*cu1 - su2*su1 ;
    U[1] = su2*cu1 + cu2*su1 ;
    U[2] = - cu2*su1 - su2*cu1 ;
    U[3] = - su2*su1 + cu2*cu1 ;
  }
  if (V) {
    V[0] = cv2 ;
    V[1] = sv2 ;
    V[2] = - sv2 ;
    V[3] = cv2 ;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rcx), %xmm0
movsd 0x8(%rcx), %xmm1
movsd 0x10(%rcx), %xmm3
movsd 0x18(%rcx), %xmm2
movapd %xmm1, %xmm4
mulsd %xmm1, %xmm4
movapd %xmm0, %xmm5
mulsd %xmm0, %xmm5
addsd %xmm4, %xmm5
sqrtsd %xmm5, %xmm4
movapd %xmm0, %xmm6
divsd %xmm4, %xmm6
movapd %xmm1, %xmm5
divsd %xmm4, %xmm5
mulsd %xmm5, %xmm1
mulsd %xmm6, %xmm0
addsd %xmm1, %xmm0
movapd %xmm2, %xmm4
mulsd %xmm5, %xmm4
movapd %xmm6, %xmm1
mulsd %xmm3, %xmm1
addsd %xmm4, %xmm1
movapd %xmm6, 0x20(%rsp)
mulsd %xmm6, %xmm2
movapd %xmm5, 0x30(%rsp)
mulsd %xmm5, %xmm3
subsd %xmm3, %xmm2
leaq 0x48(%rsp), %r12
leaq 0x40(%rsp), %r13
movq %rsp, %rdx
leaq 0x8(%rsp), %rcx
leaq 0x10(%rsp), %r8
leaq 0x18(%rsp), %r9
movq %r12, %rdi
movq %r13, %rsi
callq 0x9720
movsd (%r13), %xmm0
movsd %xmm0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movsd (%r12), %xmm0
movsd %xmm0, 0x18(%r15)
testq %r14, %r14
je 0x21567
movapd 0x30(%rsp), %xmm4
unpcklpd %xmm4, %xmm4            # xmm4 = xmm4[0,0]
movsd 0x18(%rsp), %xmm0
movapd %xmm0, %xmm1
movhpd 0x10(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
movapd 0x20(%rsp), %xmm5
unpcklpd %xmm5, %xmm5            # xmm5 = xmm5[0,0]
movapd 0xbb6d(%rip), %xmm2     # 0x2d0a0
xorpd %xmm1, %xmm2
shufpd $0x1, %xmm0, %xmm2      # xmm2 = xmm2[1],xmm0[0]
movapd %xmm4, %xmm0
mulpd %xmm2, %xmm0
movapd %xmm1, %xmm3
mulpd %xmm5, %xmm3
addpd %xmm0, %xmm3
movupd %xmm3, (%r14)
mulpd %xmm5, %xmm2
mulpd %xmm4, %xmm1
subpd %xmm1, %xmm2
movupd %xmm2, 0x10(%r14)
testq %rbx, %rbx
je 0x21592
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rbx)
movsd (%rsp), %xmm1
movsd %xmm1, 0x8(%rbx)
xorpd 0xbb18(%rip), %xmm1     # 0x2d0a0
movlpd %xmm1, 0x10(%rbx)
movsd %xmm0, 0x18(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_solve_linear_system_3
VL_EXPORT int
vl_solve_linear_system_3 (double * x, double const * A, double const *b)
{
  int err ;
  double M[3*4] ;
  M[0] = A[0] ;
  M[1] = A[1] ;
  M[2] = A[2] ;
  M[3] = A[3] ;
  M[4] = A[4] ;
  M[5] = A[5] ;
  M[6] = A[6] ;
  M[7] = A[7] ;
  M[8] = A[8] ;
  M[9] = b[0] ;
  M[10] = b[1] ;
  M[11] = b[2] ;
  err = vl_gaussian_elimination(M,3,4) ;
  x[0] = M[9] ;
  x[1] = M[10] ;
  x[2] = M[11] ;
  return err ;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movups 0x10(%rsi), %xmm0
movaps %xmm0, 0x10(%r14)
movups 0x20(%rsi), %xmm0
movaps %xmm0, 0x20(%r14)
movups 0x30(%rsi), %xmm0
movaps %xmm0, 0x30(%r14)
movsd 0x40(%rsi), %xmm0
movsd %xmm0, 0x40(%r14)
movups (%rdx), %xmm0
movups %xmm0, 0x48(%r14)
movsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x58(%r14)
pushq $0x3
popq %rsi
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x9980
movups 0x48(%r14), %xmm0
movups %xmm0, (%rbx)
movsd 0x58(%r14), %xmm0
movsd %xmm0, 0x10(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop.c
// Function: vl_solve_linear_system_2
VL_EXPORT int
vl_solve_linear_system_2 (double * x, double const * A, double const *b)
{
  int err ;
  double M[2*3] ;
  M[0] = A[0] ;
  M[1] = A[1] ;
  M[2] = A[2] ;
  M[3] = A[3] ;
  M[4] = b[0];
  M[5] = b[1] ;
  err = vl_gaussian_elimination(M,2,3) ;
  x[0] = M[4] ;
  x[1] = M[5] ;
  return err ;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movups 0x10(%rsi), %xmm0
movaps %xmm0, 0x10(%r14)
movups (%rdx), %xmm0
movaps %xmm0, 0x20(%r14)
pushq $0x2
popq %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x9980
movaps 0x20(%r14), %xmm0
movups %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_avx.c
// Function: vl_distance_l2_avx_f
VL_EXPORT T
VL_XCAT(_vl_distance_l2_avx_, SFX)
(vl_size dimension, T const * X, T const * Y)
{

  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZEavx + 1 ;
  T acc ;
  VTYPEavx vacc = VSTZavx() ;
  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPEavx a = *(VTYPEavx*)X ;
      VTYPEavx b = *(VTYPEavx*)Y ;
      VTYPEavx delta = VSUBavx(a, b) ;
      VTYPEavx delta2 = VMULavx(delta, delta) ;
      vacc = VADDavx(vacc, delta2) ;
      X += VSIZEavx ;
      Y += VSIZEavx ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPEavx a = VLDUavx(X) ;
      VTYPEavx b = VLDUavx(Y) ;
      VTYPEavx delta = VSUBavx(a, b) ;
      VTYPEavx delta2 = VMULavx(delta, delta) ;
      vacc = VADDavx(vacc, delta2) ;
      X += VSIZEavx ;
      Y += VSIZEavx ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_avx_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T delta = a - b ;
    acc += delta * delta ;
  }

  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0x1c, %rcx
movl %edx, %eax
orl %esi, %eax
vxorps %xmm0, %xmm0, %xmm0
testb $0x1f, %al
je 0x21f1b
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x21f3d
vmovups (%rax), %ymm1
vsubps (%rdx), %ymm1, %ymm1
vmulps %ymm1, %ymm1, %ymm1
vaddps %ymm1, %ymm0, %ymm0
addq $0x20, %rax
addq $0x20, %rdx
jmp 0x21efc
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x21f3d
vmovaps (%rax), %ymm1
vsubps (%rdx), %ymm1, %ymm1
vmulps %ymm1, %ymm1, %ymm1
vaddps %ymm1, %ymm0, %ymm0
addq $0x20, %rax
addq $0x20, %rdx
jmp 0x21f1e
leaq (%rsi,%rdi,4), %rcx
vhaddps %ymm0, %ymm0, %ymm0
vextractf128 $0x1, %ymm0, %xmm1
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
cmpq %rcx, %rax
jae 0x21f72
vmovss (%rax), %xmm1
vsubss (%rdx), %xmm1, %xmm1
addq $0x4, %rax
addq $0x4, %rdx
vmulss %xmm1, %xmm1, %xmm1
vaddss %xmm0, %xmm1, %xmm0
jmp 0x21f53
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_distance_l1_sse2_f
VL_EXPORT T
VL_XCAT(_vl_distance_l1_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X + dimension - VSIZE ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  VTYPE vminus = VL_XCAT(_mm_set1_p, VSFX) ((T) -0.0) ; /* sign bit */
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE delta = VSUB(a, b) ;
      vacc = VADD(vacc, VANDN(vminus, delta)) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE delta = VSUB(a, b) ;
      vacc = VADD(vacc, VANDN(vminus, delta)) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T delta = a - b ;
    acc += VL_MAX(delta, - delta) ;
  }

  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0x10, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm0, %xmm0
movaps 0xa78f(%rip), %xmm1     # 0x2d150
testb $0xf, %al
je 0x229e6
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22a04
movups (%rax), %xmm2
movups (%rdx), %xmm3
subps %xmm3, %xmm2
andps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x229c8
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22a04
movaps (%rax), %xmm2
subps (%rdx), %xmm2
andps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x229e9
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
movaps 0xa94c(%rip), %xmm1     # 0x2d370
cmpq %rcx, %rax
jae 0x22a49
movss (%rax), %xmm2
addq $0x4, %rax
subss (%rdx), %xmm2
addq $0x4, %rdx
movaps %xmm2, %xmm3
xorps %xmm1, %xmm3
maxss %xmm3, %xmm2
addss %xmm2, %xmm0
jmp 0x22a24
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_distance_chi2_sse2_f
VL_EXPORT T
VL_XCAT(_vl_distance_chi2_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X + dimension - VSIZE ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE delta = VSUB(a, b) ;
      VTYPE denom = VADD(a, b) ;
      VTYPE numer = VMUL(delta, delta) ;
      VTYPE ratio = VDIV(numer, denom) ;
      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
      vacc = VADD(vacc, ratio) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE delta = VSUB(a, b) ;
      VTYPE denom = VADD(a, b) ;
      VTYPE numer = VMUL(delta, delta) ;
      VTYPE ratio = VDIV(numer, denom) ;
      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
      vacc = VADD(vacc, ratio) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T delta = a - b ;
    T denom = a + b ;
    T numer = delta * delta ;
    if (denom) {
      T ratio = numer / denom ;
      acc += ratio ;
    }
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0x10, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testb $0xf, %al
je 0x22a91
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22ac2
movups (%rax), %xmm2
movups (%rdx), %xmm3
movaps %xmm2, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm2
mulps %xmm4, %xmm4
divps %xmm2, %xmm4
cmpneqps %xmm1, %xmm2
andps %xmm4, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22a63
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22ac2
movaps (%rax), %xmm2
movaps (%rdx), %xmm3
movaps %xmm2, %xmm4
subps %xmm3, %xmm4
addps %xmm3, %xmm2
mulps %xmm4, %xmm4
divps %xmm2, %xmm4
cmpneqps %xmm1, %xmm2
andps %xmm4, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22a94
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
cmpq %rcx, %rax
jae 0x22b1d
movss (%rax), %xmm2
addq $0x4, %rax
movss (%rdx), %xmm3
addq $0x4, %rdx
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
subss %xmm3, %xmm2
mulss %xmm2, %xmm2
divss %xmm4, %xmm2
addss %xmm0, %xmm2
cmpneqss %xmm1, %xmm4
andps %xmm4, %xmm2
andnps %xmm0, %xmm4
orps %xmm2, %xmm4
movaps %xmm4, %xmm0
jmp 0x22ade
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_kernel_l2_sse2_f
VL_EXPORT T
VL_XCAT(_vl_kernel_l2_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZE + 1 ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      vacc = VADD(vacc, VMUL(a,b)) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      vacc = VADD(vacc, VMUL(a,b)) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    acc += a * b ;
  }
  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm0, %xmm0
testb $0xf, %al
je 0x22b4f
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22b6a
movups (%rax), %xmm1
movups (%rdx), %xmm2
mulps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22b34
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22b6a
movaps (%rax), %xmm1
mulps (%rdx), %xmm1
addps %xmm1, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22b52
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
cmpq %rcx, %rax
jae 0x22b9a
movss (%rax), %xmm1
addq $0x4, %rax
mulss (%rdx), %xmm1
addq $0x4, %rdx
jmp 0x22b7f
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_kernel_l1_sse2_f
VL_EXPORT T
VL_XCAT(_vl_kernel_l1_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZE + 1 ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  VTYPE vminus = VL_XCAT(_mm_set1_p, VSFX) ((T) -0.0) ;
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE a_ = VANDN(vminus, a) ;
      VTYPE b_ = VANDN(vminus, b) ;
      VTYPE sum = VADD(a_,b_) ;
      VTYPE diff = VSUB(a, b) ;
      VTYPE diff_ = VANDN(vminus, diff) ;
      vacc = VADD(vacc, VSUB(sum, diff_)) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE a_ = VANDN(vminus, a) ;
      VTYPE b_ = VANDN(vminus, b) ;
      VTYPE sum = VADD(a_,b_) ;
      VTYPE diff = VSUB(a, b) ;
      VTYPE diff_ = VANDN(vminus, diff) ;
      vacc = VADD(vacc, VSUB(sum, diff_)) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T a_ = VL_XCAT(vl_abs_, SFX) (a) ;
    T b_ = VL_XCAT(vl_abs_, SFX) (b) ;
    acc += a_ + b_ - VL_XCAT(vl_abs_, SFX) (a - b) ;
  }

  return acc / ((T)2) ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm0, %xmm0
movaps 0xa59f(%rip), %xmm1     # 0x2d150
testb $0xf, %al
je 0x22be5
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22c15
movups (%rax), %xmm2
movups (%rdx), %xmm3
movaps %xmm2, %xmm4
andps %xmm1, %xmm4
subps %xmm3, %xmm2
andps %xmm1, %xmm3
addps %xmm4, %xmm3
andps %xmm1, %xmm2
subps %xmm2, %xmm3
addps %xmm3, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22bb8
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22c15
movaps (%rax), %xmm2
movaps (%rdx), %xmm3
movaps %xmm2, %xmm4
andps %xmm1, %xmm4
subps %xmm3, %xmm2
andps %xmm1, %xmm3
addps %xmm4, %xmm3
andps %xmm1, %xmm2
subps %xmm2, %xmm3
addps %xmm3, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22be8
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
movaps 0xa51b(%rip), %xmm1     # 0x2d150
cmpq %rcx, %rax
jae 0x22c68
movss (%rax), %xmm2
addq $0x4, %rax
movss (%rdx), %xmm3
addq $0x4, %rdx
movaps %xmm2, %xmm4
andps %xmm1, %xmm4
subss %xmm3, %xmm2
andps %xmm1, %xmm3
addss %xmm4, %xmm3
andps %xmm1, %xmm2
subss %xmm2, %xmm3
addss %xmm3, %xmm0
jmp 0x22c35
mulss 0xa6b8(%rip), %xmm0     # 0x2d328
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_kernel_chi2_sse2_f
VL_EXPORT T
VL_XCAT(_vl_kernel_chi2_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X + dimension - VSIZE ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE denom = VADD(a, b) ;
      VTYPE numer = VMUL(a,b) ;
      VTYPE ratio = VDIV(numer, denom) ;
      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
      vacc = VADD(vacc, ratio) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE denom = VADD(a, b) ;
      VTYPE numer = VMUL(a,b) ;
      VTYPE ratio = VDIV(numer, denom) ;
      ratio = VAND(ratio, VNEQ(denom, VSTZ())) ;
      vacc = VADD(vacc, ratio) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T denom = a + b ;
    if (denom) {
      T ratio = a * b / denom ;
      acc += ratio ;
    }
  }
  return ((T)2) * acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0x10, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm1, %xmm1
xorps %xmm0, %xmm0
testb $0xf, %al
je 0x22cb5
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22ce3
movups (%rax), %xmm2
movups (%rdx), %xmm3
movaps %xmm2, %xmm4
addps %xmm3, %xmm4
mulps %xmm3, %xmm2
divps %xmm4, %xmm2
cmpneqps %xmm1, %xmm4
andps %xmm2, %xmm4
addps %xmm4, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22c8a
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x22ce3
movaps (%rax), %xmm2
movaps (%rdx), %xmm3
movaps %xmm2, %xmm4
addps %xmm3, %xmm4
mulps %xmm3, %xmm2
divps %xmm4, %xmm2
cmpneqps %xmm1, %xmm4
andps %xmm2, %xmm4
addps %xmm4, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22cb8
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
cmpq %rcx, %rax
jae 0x22d3a
movss (%rax), %xmm2
addq $0x4, %rax
movss (%rdx), %xmm3
addq $0x4, %rdx
movaps %xmm2, %xmm4
addss %xmm3, %xmm4
mulss %xmm3, %xmm2
divss %xmm4, %xmm2
addss %xmm0, %xmm2
cmpneqss %xmm1, %xmm4
andps %xmm4, %xmm2
andnps %xmm0, %xmm4
orps %xmm2, %xmm4
movaps %xmm4, %xmm0
jmp 0x22cff
addss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_dot_sse2_f
VL_EXPORT T
VL_XCAT(_vl_dot_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZE + 1 ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE d = VMUL(a, b) ;
      vacc = VADD(vacc, d) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE d = VMUL(a, b) ;
      vacc = VADD(vacc, d) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    acc += a * b ;
  }

  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm0, %xmm0
testb $0xf, %al
je 0x22830
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x2284b
movups (%rax), %xmm1
movups (%rdx), %xmm2
mulps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22815
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x2284b
movaps (%rax), %xmm1
mulps (%rdx), %xmm1
addps %xmm1, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22833
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
cmpq %rcx, %rax
jae 0x2287b
movss (%rax), %xmm1
addq $0x4, %rax
mulss (%rdx), %xmm1
addq $0x4, %rdx
jmp 0x22860
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_distance_l2_sse2_f
VL_EXPORT T
VL_XCAT(_vl_distance_l2_sse2_, SFX)
(vl_size dimension, T const * X, T const * Y)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZE + 1 ;
  T acc ;
  VTYPE vacc = VSTZ() ;
  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE delta = VSUB(a, b) ;
      VTYPE delta2 = VMUL(delta, delta) ;
      vacc = VADD(vacc, delta2) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE delta = VSUB(a, b) ;
      VTYPE delta2 = VMUL(delta, delta) ;
      vacc = VADD(vacc, delta2) ;
      X += VSIZE ;
      Y += VSIZE ;
    }
  }

  acc = VL_XCAT(_vl_vhsum_sse2_, SFX)(vacc) ;

  while (X < X_end) {
    T a = *X++ ;
    T b = *Y++ ;
    T delta = a - b ;
    acc += delta * delta ;
  }

  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %eax
orl %esi, %eax
xorps %xmm0, %xmm0
testb $0xf, %al
je 0x228b0
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x228ce
movups (%rax), %xmm1
movups (%rdx), %xmm2
subps %xmm2, %xmm1
mulps %xmm1, %xmm1
addps %xmm1, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x22892
movq %rsi, %rax
cmpq %rcx, %rax
jae 0x228ce
movaps (%rax), %xmm1
subps (%rdx), %xmm1
mulps %xmm1, %xmm1
addps %xmm1, %xmm0
addq $0x10, %rax
addq $0x10, %rdx
jmp 0x228b3
leaq (%rsi,%rdi,4), %rcx
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addps %xmm0, %xmm1
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0     # xmm0 = xmm0[1,1],xmm1[1,1]
addss %xmm1, %xmm0
cmpq %rcx, %rax
jae 0x22902
movss (%rax), %xmm1
subss (%rdx), %xmm1
addq $0x4, %rax
addq $0x4, %rdx
mulss %xmm1, %xmm1
jmp 0x228e3
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mser.c
// Function: vl_mser_new
VL_EXPORT
VlMserFilt*
vl_mser_new (int ndims, int const* dims)
{
  VlMserFilt* f ;
  int *strides, k ;

  f = vl_calloc (sizeof(VlMserFilt), 1) ;

  f-> ndims   = ndims ;
  f-> dims    = vl_malloc (sizeof(int) * ndims) ;
  f-> subs    = vl_malloc (sizeof(int) * ndims) ;
  f-> dsubs   = vl_malloc (sizeof(int) * ndims) ;
  f-> strides = vl_malloc (sizeof(int) * ndims) ;

  /* shortcuts */
  strides = f-> strides ;

  /* copy dims to f->dims */
  for(k = 0 ; k < ndims ; ++k) {
    f-> dims [k] = dims [k] ;
  }

  /* compute strides to move into the N-dimensional image array */
  strides [0] = 1 ;
  for(k = 1 ; k < ndims ; ++k) {
    strides [k] = strides [k-1] * dims [k-1] ;
  }

  /* total number of pixels */
  f-> nel = strides [ndims-1] * dims [ndims-1] ;

  /* dof of ellipsoids */
  f-> dof = ndims * (ndims + 1) / 2 + ndims ;

  /* more buffers */
  f-> perm   = vl_malloc (sizeof(vl_uint)   * f-> nel) ;
  f-> joins  = vl_malloc (sizeof(vl_uint)   * f-> nel) ;
  f-> r      = vl_malloc (sizeof(VlMserReg) * f-> nel) ;

  f-> er     = 0 ;
  f-> rer    = 0 ;
  f-> mer    = 0 ;
  f-> rmer   = 0 ;
  f-> ell    = 0 ;
  f-> rell   = 0 ;

  /* other parameters */
  f-> delta         = 5 ;
  f-> max_area      = 0.75 ;
  f-> min_area      = 3.0 / f-> nel ;
  f-> max_variation = 0.25 ;
  f-> min_diversity = 0.2 ;

  return f ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
pushq $0x1
popq %r15
movl $0xd0, %edi
movq %r15, %rsi
callq 0x9960
movq %rax, %rbx
movl %ebp, (%rax)
movslq %ebp, %r13
leaq (,%r13,4), %r12
movq %r12, %rdi
callq 0x95e0
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x95e0
movq %rax, 0x18(%rbx)
movq %r12, %rdi
callq 0x95e0
movq %rax, 0x20(%rbx)
movq %r12, %rdi
callq 0x95e0
movq %rax, 0x28(%rbx)
xorl %ecx, %ecx
testl %r13d, %r13d
movl $0x0, %edx
cmovgl %r13d, %edx
cmpq %rcx, %rdx
je 0x22ee0
movl (%r14,%rcx,4), %esi
movq 0x8(%rbx), %rdi
movl %esi, (%rdi,%rcx,4)
incq %rcx
jmp 0x22ecb
movl $0x1, (%rax)
pushq $0x1
popq %rcx
cmpq %r13, %r15
jge 0x22efd
imull -0x4(%r14,%r15,4), %ecx
movl %ecx, (%rax,%r15,4)
incq %r15
jmp 0x22ee9
movslq -0x4(%rax,%r13,4), %rax
movslq -0x4(%r14,%r13,4), %rdi
imulq %rax, %rdi
movl %edi, 0x10(%rbx)
leal 0x1(%r13), %eax
imull %r13d, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
addl %r13d, %eax
movl %eax, 0x88(%rbx)
shlq $0x2, %rdi
callq 0x95e0
movq %rax, 0x30(%rbx)
movslq 0x10(%rbx), %rdi
shlq $0x2, %rdi
callq 0x95e0
movq %rax, 0x38(%rbx)
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
callq 0x95e0
movq %rax, 0x48(%rbx)
andq $0x0, 0x68(%rbx)
andq $0x0, 0x78(%rbx)
andl $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movl $0x5, 0x90(%rbx)
movabsq $0x3fe8000000000000, %rax # imm = 0x3FE8000000000000
movq %rax, 0x98(%rbx)
cvtsi2sdl 0x10(%rbx), %xmm0
movsd 0xa254(%rip), %xmm1     # 0x2d1e8
divsd %xmm0, %xmm1
movsd %xmm1, 0xa0(%rbx)
movaps 0xb1f9(%rip), %xmm0     # 0x2e1a0
movups %xmm0, 0xa8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mser.c
// Function: vl_mser_delete
VL_EXPORT
void
vl_mser_delete (VlMserFilt* f)
{
  if(f) {
    if(f-> acc   )  vl_free( f-> acc    ) ;
    if(f-> ell   )  vl_free( f-> ell    ) ;

    if(f-> er    )  vl_free( f-> er     ) ;
    if(f-> r     )  vl_free( f-> r      ) ;
    if(f-> joins )  vl_free( f-> joins  ) ;
    if(f-> perm  )  vl_free( f-> perm   ) ;

    if(f-> strides) vl_free( f-> strides) ;
    if(f-> dsubs  ) vl_free( f-> dsubs  ) ;
    if(f-> subs   ) vl_free( f-> subs   ) ;
    if(f-> dims   ) vl_free( f-> dims   ) ;

    if(f-> mer    ) vl_free( f-> mer    ) ;
    vl_free (f) ;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x23070
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x22fdb
callq 0x95b0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x22fe9
callq 0x95b0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x22ff7
callq 0x95b0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x23005
callq 0x95b0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x23013
callq 0x95b0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x23021
callq 0x95b0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2302f
callq 0x95b0
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2303d
callq 0x95b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2304b
callq 0x95b0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x23059
callq 0x95b0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x23067
callq 0x95b0
movq %rbx, %rdi
popq %rbx
jmp 0x95b0
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/mser.c
// Function: adv
VL_INLINE void
adv(int ndims, int const *dims, int *subs)
{
  int d = 0 ;
  while(d < ndims) {
    if( ++subs[d]  < dims[d] ) return ;
    subs[d++] = 0 ;
  }
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
cmpq %rax, %rdi
je 0x23aab
movl (%rdx,%rax,4), %ecx
incl %ecx
movl %ecx, (%rdx,%rax,4)
cmpl (%rsi,%rax,4), %ecx
jl 0x23aab
andl $0x0, (%rdx,%rax,4)
incq %rax
jmp 0x23a90
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/pgm.c
// Function: remove_blanks
static int
remove_blanks(FILE* f)
{
  int count = 0 ;
  int c ;

  while (1) {
    c = fgetc(f) ;

    switch(c) {

    case '\t' : case '\n' :
    case '\r' : case ' '  :
      ++ count ;
      break ;

    case '#' :
      count += 1 + remove_line(f) ;
      break ;

    case EOF :
      goto quit_remove_blanks ;

    default:
      ungetc(c, f) ;
      goto quit_remove_blanks ;
    }
  }
 quit_remove_blanks:
  return count ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0x1
popq %rbp
movabsq $0x200004c00, %r15      # imm = 0x200004C00
movq %r14, %rdi
callq 0x9440
leal 0x1(%rax), %ecx
cmpl $0x24, %ecx
ja 0x23c98
btq %rcx, %r15
movl %ebp, %r12d
jae 0x23c6e
addl %r12d, %ebx
jmp 0x23c50
cmpq $0x24, %rcx
jne 0x23c93
movl %ebp, %r12d
movq %r14, %rdi
callq 0x9440
incl %r12d
cmpl $-0x1, %eax
je 0x23c8e
cmpl $0xa, %eax
jne 0x23c77
jmp 0x23c69
decl %r12d
jmp 0x23c69
testq %rcx, %rcx
je 0x23ca2
movl %eax, %edi
movq %r14, %rsi
callq 0x96e0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq