LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0x1c, %rcx
movl %edx, %edi
orl %esi, %edi
vxorps %xmm0, %xmm0, %xmm0
testb $0x1f, %dil
je 0x264b1
cmpq %rsi, %rcx
jbe 0x264d3
vmovups (%rsi), %ymm1
vsubps (%rdx), %ymm1, %ymm1
vmulps %ymm1, %ymm1, %ymm1
vaddps %ymm1, %ymm0, %ymm0
addq $0x20, %rsi
addq $0x20, %rdx
cmpq %rcx, %rsi
jb 0x26492
jmp 0x264d3
cmpq %rsi, %rcx
jbe 0x264d3
vmovaps (%rsi), %ymm1
vsubps (%rdx), %ymm1, %ymm1
vmulps %ymm1, %ymm1, %ymm1
vaddps %ymm1, %ymm0, %ymm0
addq $0x20, %rsi
addq $0x20, %rdx
cmpq %rcx, %rsi
jb 0x264b6
vhaddps %ymm0, %ymm0, %ymm0
vextractf128 $0x1, %ymm0, %xmm1
vaddps %xmm1, %xmm0, %xmm0
vhaddps %xmm0, %xmm0, %xmm0
cmpq %rax, %rsi
jae 0x26504
vmovss (%rsi), %xmm1
addq $0x4, %rsi
vsubss (%rdx), %xmm1, %xmm1
addq $0x4, %rdx
vmulss %xmm1, %xmm1, %xmm1
vaddss %xmm0, %xmm1, %xmm0
jmp 0x264e5
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/mathop_avx.c
// Function: vl_weighted_sigma_avx_d
VL_EXPORT void
VL_XCAT(_vl_weighted_sigma_avx_, SFX)
(vl_size dimension, T * S, T const * X, T const * Y, T const W)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZEavx + 1 ;

  vl_bool dataAligned = VALIGNEDavx(X) & VALIGNEDavx(Y) & VALIGNEDavx(S);

  VTYPEavx w = VLD1avx (&W) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPEavx a = *(VTYPEavx*)X ;
      VTYPEavx b = *(VTYPEavx*)Y ;
      VTYPEavx s = *(VTYPEavx*)S ;

      VTYPEavx delta = VSUBavx(a, b) ;
      VTYPEavx delta2 = VMULavx(delta, delta) ;
      VTYPEavx delta2w = VMULavx(delta2, w) ;
      VTYPEavx sigmaStore = VADDavx(s,delta2w);

      *(VTYPEavx *)S = sigmaStore;

      X += VSIZEavx ;
      Y += VSIZEavx ;
      S += VSIZEavx ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPEavx a = VLDUavx(X) ;
      VTYPEavx b = VLDUavx(Y) ;
      VTYPEavx s = VLDUavx(S) ;

      VTYPEavx delta = VSUBavx(a, b) ;
      VTYPEavx delta2 = VMULavx(delta, delta) ;
      VTYPEavx delta2w = VMULavx(delta2, w) ;
      VTYPEavx sigmaStore = VADDavx(s,delta2w);

      VST2Uavx(S,sigmaStore);

      X += VSIZEavx ;
      Y += VSIZEavx ;
      S += VSIZEavx ;
    }
  }

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

// Assembly:
leaq (%rdx,%rdi,8), %rax
leaq (%rdx,%rdi,8), %rdi
addq $-0x18, %rdi
movl %edx, %r8d
orl %esi, %r8d
movl %ecx, %r9d
orl %r8d, %r9d
vmovddup %xmm0, %xmm1            # xmm1 = xmm0[0,0]
vinsertf128 $0x1, %xmm1, %ymm1, %ymm1
testb $0x1f, %r9b
je 0x2640c
cmpq %rdx, %rdi
jbe 0x2643a
vmovupd (%rdx), %ymm2
vsubpd (%rcx), %ymm2, %ymm2
vmulpd %ymm2, %ymm2, %ymm2
vmulpd %ymm2, %ymm1, %ymm2
vaddpd (%rsi), %ymm2, %ymm2
vmovupd %ymm2, (%rsi)
addq $0x20, %rdx
addq $0x20, %rcx
addq $0x20, %rsi
cmpq %rdi, %rdx
jb 0x263e1
jmp 0x2643a
cmpq %rdx, %rdi
jbe 0x2643a
vmovapd (%rdx), %ymm2
vsubpd (%rcx), %ymm2, %ymm2
vmulpd %ymm2, %ymm2, %ymm2
vmulpd %ymm2, %ymm1, %ymm2
vaddpd (%rsi), %ymm2, %ymm2
vmovapd %ymm2, (%rsi)
addq $0x20, %rdx
addq $0x20, %rcx
addq $0x20, %rsi
cmpq %rdi, %rdx
jb 0x26411
cmpq %rax, %rdx
jae 0x2646f
xorl %edi, %edi
leaq (%rdx,%rdi), %r8
addq $0x8, %r8
vmovsd -0x8(%r8), %xmm1
vsubsd (%rcx,%rdi), %xmm1, %xmm1
vmulsd %xmm1, %xmm1, %xmm1
vmulsd %xmm0, %xmm1, %xmm1
vaddsd (%rsi,%rdi), %xmm1, %xmm1
vmovsd %xmm1, (%rsi,%rdi)
addq $0x8, %rdi
cmpq %rax, %r8
jb 0x26441
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x26e65
cmpq %rsi, %rcx
jbe 0x26e80
movups (%rsi), %xmm1
movups (%rdx), %xmm2
mulps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x26e4a
jmp 0x26e80
cmpq %rsi, %rcx
jbe 0x26e80
movaps (%rsi), %xmm1
mulps (%rdx), %xmm1
addps %xmm1, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x26e6a
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 %rax, %rsi
jae 0x26eac
movss (%rsi), %xmm1
mulss (%rdx), %xmm1
addq $0x4, %rsi
addq $0x4, %rdx
jmp 0x26e91
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x26ee9
cmpq %rsi, %rcx
jbe 0x26f07
movups (%rsi), %xmm1
movups (%rdx), %xmm2
subps %xmm2, %xmm1
mulps %xmm1, %xmm1
addps %xmm1, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x26ecb
jmp 0x26f07
cmpq %rsi, %rcx
jbe 0x26f07
movaps (%rsi), %xmm1
subps (%rdx), %xmm1
mulps %xmm1, %xmm1
addps %xmm1, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x26eee
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 %rax, %rsi
jae 0x26f37
movss (%rsi), %xmm1
addq $0x4, %rsi
subss (%rdx), %xmm1
addq $0x4, %rdx
mulss %xmm1, %xmm1
jmp 0x26f18
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0x10, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x27034
cmpq %rsi, %rcx
jbe 0x27059
movaps 0xc15a(%rip), %xmm1     # 0x33170
movups (%rsi), %xmm2
movups (%rdx), %xmm3
subps %xmm3, %xmm2
andps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x27016
jmp 0x27059
cmpq %rsi, %rcx
jbe 0x27059
movaps 0xc130(%rip), %xmm1     # 0x33170
movaps (%rsi), %xmm2
subps (%rdx), %xmm2
andps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x27040
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 %rax, %rsi
jae 0x2709d
movaps 0xbf96(%rip), %xmm1     # 0x33010
movss (%rsi), %xmm2
addq $0x4, %rsi
subss (%rdx), %xmm2
addq $0x4, %rdx
movaps %xmm2, %xmm3
xorps %xmm1, %xmm3
maxss %xmm3, %xmm2
addss %xmm2, %xmm0
cmpq %rax, %rsi
jb 0x2707a
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0x10, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x270ed
cmpq %rsi, %rcx
jbe 0x27121
xorps %xmm1, %xmm1
movups (%rsi), %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, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x270bf
jmp 0x27121
cmpq %rsi, %rcx
jbe 0x27121
xorps %xmm1, %xmm1
movaps (%rsi), %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, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x270f5
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addps %xmm0, %xmm2
movaps %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm1     # xmm1 = xmm1[1,1],xmm2[1,1]
addss %xmm2, %xmm1
cmpq %rax, %rsi
jae 0x2717c
xorps %xmm2, %xmm2
movss (%rsi), %xmm3
addq $0x4, %rsi
movss (%rdx), %xmm4
addq $0x4, %rdx
movaps %xmm3, %xmm0
addss %xmm4, %xmm0
subss %xmm4, %xmm3
mulss %xmm3, %xmm3
divss %xmm0, %xmm3
addss %xmm1, %xmm3
cmpneqss %xmm2, %xmm0
andps %xmm0, %xmm3
andnps %xmm1, %xmm0
orps %xmm3, %xmm0
movaps %xmm0, %xmm1
cmpq %rax, %rsi
jb 0x2713e
retq
movaps %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x271b9
cmpq %rsi, %rcx
jbe 0x271d4
movups (%rsi), %xmm1
movups (%rdx), %xmm2
mulps %xmm1, %xmm2
addps %xmm2, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x2719e
jmp 0x271d4
cmpq %rsi, %rcx
jbe 0x271d4
movaps (%rsi), %xmm1
mulps (%rdx), %xmm1
addps %xmm1, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x271be
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 %rax, %rsi
jae 0x27200
movss (%rsi), %xmm1
mulss (%rdx), %xmm1
addq $0x4, %rsi
addq $0x4, %rdx
jmp 0x271e5
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0xc, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x27253
cmpq %rsi, %rcx
jbe 0x2728a
movaps 0xbf4a(%rip), %xmm1     # 0x33170
movups (%rsi), %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, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x27226
jmp 0x2728a
cmpq %rsi, %rcx
jbe 0x2728a
movaps 0xbf11(%rip), %xmm1     # 0x33170
movaps (%rsi), %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, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x2725f
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 %rax, %rsi
jae 0x272dc
movaps 0xbec5(%rip), %xmm1     # 0x33170
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
cmpq %rax, %rsi
jb 0x272ab
mulss 0xc06c(%rip), %xmm0     # 0x33350
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
leaq (%rsi,%rdi,4), %rcx
addq $-0x10, %rcx
movl %edx, %edi
orl %esi, %edi
xorps %xmm0, %xmm0
testb $0xf, %dil
je 0x27331
cmpq %rsi, %rcx
jbe 0x27362
xorps %xmm1, %xmm1
movups (%rsi), %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, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x27306
jmp 0x27362
cmpq %rsi, %rcx
jbe 0x27362
xorps %xmm1, %xmm1
movaps (%rsi), %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, %rsi
addq $0x10, %rdx
cmpq %rcx, %rsi
jb 0x27339
movaps %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addps %xmm0, %xmm2
movaps %xmm2, %xmm1
shufps $0x55, %xmm2, %xmm1     # xmm1 = xmm1[1,1],xmm2[1,1]
addss %xmm2, %xmm1
cmpq %rax, %rsi
jae 0x273ba
xorps %xmm2, %xmm2
movss (%rsi), %xmm3
addq $0x4, %rsi
movss (%rdx), %xmm4
addq $0x4, %rdx
movaps %xmm3, %xmm0
addss %xmm4, %xmm0
mulss %xmm4, %xmm3
divss %xmm0, %xmm3
addss %xmm1, %xmm3
cmpneqss %xmm2, %xmm0
andps %xmm0, %xmm3
andnps %xmm1, %xmm0
orps %xmm3, %xmm0
movaps %xmm0, %xmm1
cmpq %rax, %rsi
jb 0x2737f
jmp 0x273bd
movaps %xmm1, %xmm0
addss %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_weighted_sigma_sse2_d
VL_EXPORT void
VL_XCAT(_vl_weighted_sigma_sse2_, SFX)
(vl_size dimension, T * S, T const * X, T const * Y, T const W)
{
  T const * X_end = X + dimension ;
  T const * X_vec_end = X_end - VSIZE + 1 ;

  vl_bool dataAligned = VALIGNED(X) & VALIGNED(Y) & VALIGNED(S);

  VTYPE w = VLD1 (&W) ;

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)Y ;
      VTYPE s = *(VTYPE*)S ;

      VTYPE delta = VSUB(a, b) ;
      VTYPE delta2 = VMUL(delta, delta) ;
      VTYPE delta2w = VMUL(delta2, w) ;
      VTYPE sigmaStore = VADD(s,delta2w);

      *(VTYPE *)S = sigmaStore;

      X += VSIZE ;
      Y += VSIZE ;
      S += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {
      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(Y) ;
      VTYPE s = VLDU(S) ;

      VTYPE delta = VSUB(a, b) ;
      VTYPE delta2 = VMUL(delta, delta) ;
      VTYPE delta2w = VMUL(delta2, w) ;
      VTYPE sigmaStore = VADD(s,delta2w);

      VST2U(S,sigmaStore);

      X += VSIZE ;
      Y += VSIZE ;
      S += VSIZE ;
    }
  }


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

// Assembly:
leaq (%rdx,%rdi,8), %rax
leaq (%rdx,%rdi,8), %rdi
addq $-0x8, %rdi
movl %edx, %r8d
orl %esi, %r8d
movl %ecx, %r9d
orl %r8d, %r9d
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
testb $0xf, %r9b
je 0x26d40
cmpq %rdx, %rdi
jbe 0x26d6e
movupd (%rdx), %xmm2
movupd (%rcx), %xmm3
subpd %xmm3, %xmm2
movupd (%rsi), %xmm3
mulpd %xmm2, %xmm2
mulpd %xmm1, %xmm2
addpd %xmm3, %xmm2
movupd %xmm2, (%rsi)
addq $0x10, %rdx
addq $0x10, %rcx
addq $0x10, %rsi
cmpq %rdi, %rdx
jb 0x26d0d
jmp 0x26d6e
cmpq %rdx, %rdi
jbe 0x26d6e
movapd (%rdx), %xmm2
subpd (%rcx), %xmm2
mulpd %xmm2, %xmm2
mulpd %xmm1, %xmm2
addpd (%rsi), %xmm2
movapd %xmm2, (%rsi)
addq $0x10, %rdx
addq $0x10, %rcx
addq $0x10, %rsi
cmpq %rdi, %rdx
jb 0x26d45
cmpq %rax, %rdx
jae 0x26da3
xorl %edi, %edi
leaq (%rdx,%rdi), %r8
addq $0x8, %r8
movsd -0x8(%r8), %xmm1
subsd (%rcx,%rdi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
addsd (%rsi,%rdi), %xmm1
movsd %xmm1, (%rsi,%rdi)
addq $0x8, %rdi
cmpq %rax, %r8
jb 0x26d75
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/mathop_sse2.c
// Function: vl_distance_mahalanobis_sq_sse2_f
VL_EXPORT T
VL_XCAT(_vl_distance_mahalanobis_sq_sse2_, SFX)
(vl_size dimension, T const * X, T const * MU, T const * S)
{
  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(MU) & VALIGNED(S);

  if (dataAligned) {
    while (X < X_vec_end) {
      VTYPE a = *(VTYPE*)X ;
      VTYPE b = *(VTYPE*)MU ;
      VTYPE c = *(VTYPE*)S ;

      VTYPE delta = VSUB(a, b) ;
      VTYPE delta2 = VMUL(delta, delta) ;
      VTYPE delta2div = VMUL(delta2,c);

      vacc = VADD(vacc, delta2div) ;

      X  += VSIZE ;
      MU += VSIZE ;
      S  += VSIZE ;
    }
  } else {
    while (X < X_vec_end) {

      VTYPE a = VLDU(X) ;
      VTYPE b = VLDU(MU) ;
      VTYPE c = VLDU(S) ;

      VTYPE delta = VSUB(a, b) ;
      VTYPE delta2 = VMUL(delta, delta) ;
      VTYPE delta2div = VMUL(delta2,c);

      vacc = VADD(vacc, delta2div) ;

      X  += VSIZE ;
      MU += VSIZE ;
      S  += VSIZE ;
    }
  }

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

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

  return acc ;
}

// Assembly:
leaq (%rsi,%rdi,4), %rax
leaq (%rsi,%rdi,4), %rdi
addq $-0xc, %rdi
movl %edx, %r8d
orl %esi, %r8d
movl %ecx, %r9d
orl %r8d, %r9d
xorps %xmm0, %xmm0
testb $0xf, %r9b
je 0x26f86
cmpq %rsi, %rdi
jbe 0x26fab
movups (%rsi), %xmm1
movups (%rdx), %xmm2
subps %xmm2, %xmm1
movups (%rcx), %xmm2
mulps %xmm1, %xmm1
mulps %xmm2, %xmm1
addps %xmm1, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
addq $0x10, %rcx
cmpq %rdi, %rsi
jb 0x26f5e
jmp 0x26fab
cmpq %rsi, %rdi
jbe 0x26fab
movaps (%rsi), %xmm1
subps (%rdx), %xmm1
mulps %xmm1, %xmm1
mulps (%rcx), %xmm1
addps %xmm1, %xmm0
addq $0x10, %rsi
addq $0x10, %rdx
addq $0x10, %rcx
cmpq %rdi, %rsi
jb 0x26f8b
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 %rax, %rsi
jae 0x26ff0
xorl %edi, %edi
leaq (%rsi,%rdi), %r8
addq $0x4, %r8
movss -0x4(%r8), %xmm1
subss (%rdx,%rdi), %xmm1
mulss %xmm1, %xmm1
mulss (%rcx,%rdi), %xmm1
addss %xmm1, %xmm0
addq $0x4, %rdi
cmpq %rax, %r8
jb 0x26fc7
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movl %edi, %r14d
movl $0xd0, %edi
movl $0x1, %esi
callq 0x98f0
movq %rax, %rbx
movl %r14d, (%rax)
movslq %r14d, %r13
leaq (,%r13,4), %r12
movq %r12, %rdi
callq 0x95b0
movq %rax, 0x8(%rbx)
movq %r12, %rdi
callq 0x95b0
movq %rax, 0x18(%rbx)
movq %r12, %rdi
callq 0x95b0
movq %rax, 0x20(%rbx)
movq %r12, %rdi
callq 0x95b0
movq %rax, 0x28(%rbx)
movl %r14d, %ecx
testl %r13d, %r13d
jle 0x27570
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movl (%r15,%rsi,4), %edi
movl %edi, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x27561
movl $0x1, (%rax)
cmpl $0x2, %r14d
jl 0x27594
movl (%rax), %edx
decq %rcx
xorl %esi, %esi
imull (%r15,%rsi,4), %edx
movl %edx, 0x4(%rax,%rsi,4)
incq %rsi
cmpq %rsi, %rcx
jne 0x27583
movslq -0x4(%rax,%r13,4), %rax
movslq -0x4(%r15,%r13,4), %rdi
imulq %rax, %rdi
movl %edi, 0x10(%rbx)
leal 0x1(%r14), %eax
imull %r14d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %r14d, %ecx
movl %ecx, 0x88(%rbx)
shlq $0x2, %rdi
callq 0x95b0
movq %rax, 0x30(%rbx)
movslq 0x10(%rbx), %rdi
shlq $0x2, %rdi
callq 0x95b0
movq %rax, 0x38(%rbx)
movslq 0x10(%rbx), %rdi
shlq $0x4, %rdi
callq 0x95b0
movq %rax, 0x48(%rbx)
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movl $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movl $0x5, 0x90(%rbx)
movabsq $0x3fe8000000000000, %rax # imm = 0x3FE8000000000000
movq %rax, 0x98(%rbx)
xorps %xmm0, %xmm0
cvtsi2sdl 0x10(%rbx), %xmm0
movsd 0xbbdc(%rip), %xmm1     # 0x33210
divsd %xmm0, %xmm1
movsd %xmm1, 0xa0(%rbx)
movaps 0xcbe9(%rip), %xmm0     # 0x34230
movups %xmm0, 0xa8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2770b
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x27676
callq 0x9580
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x27684
callq 0x9580
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x27692
callq 0x9580
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x276a0
callq 0x9580
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x276ae
callq 0x9580
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x276bc
callq 0x9580
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x276ca
callq 0x9580
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x276d8
callq 0x9580
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x276e6
callq 0x9580
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x276f4
callq 0x9580
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x27702
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movabsq $0x200004c00, %r15      # imm = 0x200004C00
movq %r14, %rdi
callq 0x9420
leal 0x1(%rax), %ecx
cmpl $0x24, %ecx
ja 0x285a8
movl $0x1, %ebp
btq %rcx, %r15
jae 0x2857c
addl %ebp, %ebx
jmp 0x2855d
cmpq $0x24, %rcx
jne 0x285a3
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x9420
incl %ebp
cmpl $0xa, %eax
je 0x2859d
cmpl $-0x1, %eax
jne 0x28587
jmp 0x2859f
incl %ebp
incl %ebp
jmp 0x28578
testq %rcx, %rcx
je 0x285b2
movl %eax, %edi
movq %r14, %rsi
callq 0x96a0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_extract_data
VL_EXPORT
int
vl_pgm_extract_data (FILE* f, VlPgmImage const *im, void *data)
{
  vl_size bpp = vl_pgm_get_bpp(im) ;
  vl_size data_size = vl_pgm_get_npixels(im) ;
  vl_bool good = 1 ;
  size_t c ;

  /* -----------------------------------------------------------------
   *                                                         read data
   * -------------------------------------------------------------- */

  /*
     In RAW mode we read directly an array of bytes or shorts.  In
     the latter case, however, we must take care of the
     endianess. PGM files are sorted in big-endian format. If our
     architecture is little endian, we must do a conversion.
  */
  if (im->is_raw) {

    c = fread( data,
               bpp,
               data_size,
               f ) ;
    good = (c == data_size) ;

    /* adjust endianess */
#if defined(VL_ARCH_LITTLE_ENDIAN)
    if (bpp == 2) {
      vl_uindex i ;
      vl_uint8 *pt = (vl_uint8*) data ;
      for(i = 0 ; i < 2 * data_size ; i += 2) {
        vl_uint8 tmp = pt [i] ;
        pt [i]   = pt [i+1] ;
        pt [i+1] = tmp ;
      }
    }
#endif
  }
  /*
     In ASCII mode we read a sequence of decimal numbers separated
     by whitespaces.
  */
  else {
    vl_uindex i ;
    int unsigned v ;
    for(good = 1, i = 0 ;
        i < data_size && good ;
        ++i) {
      c = fscanf(f, " %ud", &v) ;
      if (bpp == 1) {
        * ((vl_uint8* )  data + i) = (vl_uint8)  v ;
      } else {
        * ((vl_uint16*)  data + i) = (vl_uint16) v ;
      }
      good &= c == 1 ;
    }
  }

  if(! good ) {
    return vl_set_last_error(VL_ERR_PGM_INV_DATA, "Invalid PGM data") ;
  }
  return 0 ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbp
imulq (%rsi), %r14
cmpl $0x0, 0x18(%rsi)
je 0x28628
cmpq $0x100, %rbp            # imm = 0x100
movl $0x2, %esi
sbbq $0x0, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x91c0
xorl %ecx, %ecx
cmpq %r14, %rax
sete %cl
cmpq $0x100, %rbp            # imm = 0x100
jb 0x28682
addq %r14, %r14
je 0x28682
xorl %eax, %eax
rolw $0x8, (%rbx,%rax)
addq $0x2, %rax
cmpq %r14, %rax
jb 0x28618
jmp 0x28682
testq %r14, %r14
je 0x2867d
movl $0x1, %r12d
leaq 0x4(%rsp), %r13
movq %r15, %rdi
leaq 0xbc35(%rip), %rsi      # 0x34277
movq %r13, %rdx
xorl %eax, %eax
callq 0x9120
movl 0x4(%rsp), %ecx
cmpq $0xff, %rbp
ja 0x28660
movb %cl, -0x1(%rbx,%r12)
jmp 0x28666
movw %cx, -0x2(%rbx,%r12,2)
cmpq %r14, %r12
jae 0x28673
incq %r12
cmpl $0x1, %eax
je 0x28638
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
jmp 0x28682
movl $0x1, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x2869b
leaq 0xbbed(%rip), %rsi      # 0x3427c
movl $0x67, %edi
xorl %eax, %eax
callq 0x9150
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_read_new
VL_EXPORT
int vl_pgm_read_new (char const *name, VlPgmImage *im, vl_uint8** data)
{
  int err = 0 ;
  FILE *f = fopen (name, "rb") ;

  if (! f) {
    return vl_set_last_error(VL_ERR_PGM_IO, "Error opening PGM file `%s' for reading", name) ;
  }

  err = vl_pgm_extract_head(f, im) ;
  if (err) {
    fclose (f) ;
    return err ;
  }

  if (vl_pgm_get_bpp(im) > 1) {
    return vl_set_last_error(VL_ERR_BAD_ARG, "PGM with BPP > 1 not supported") ;
  }

  *data = vl_malloc (vl_pgm_get_npixels(im) * sizeof(vl_uint8)) ;
  err = vl_pgm_extract_data(f, im, *data) ;

  if (err) {
    vl_free (data) ;
    fclose (f) ;
  }

  fclose (f) ;
  return err ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xbb1e(%rip), %rsi      # 0x342b1
callq 0x97f0
testq %rax, %rax
je 0x287c4
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x93c0
testl %eax, %eax
je 0x287e2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x92a0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbae9(%rip), %rsi      # 0x342b4
movl $0x68, %edi
movq %r12, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9150
cmpq $0x100, 0x10(%r15)      # imm = 0x100
jb 0x28807
leaq 0xbae9(%rip), %rsi      # 0x342dc
movl $0x3, %edi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9150
movq 0x8(%r15), %rdi
imulq (%r15), %rdi
callq 0x95b0
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x96c0
movl %eax, %ebp
testl %eax, %eax
je 0x287b1
movq %r14, %rdi
callq 0x9580
movq %rbx, %rdi
callq 0x92a0
jmp 0x287b1
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_read_new_f
VL_EXPORT
int vl_pgm_read_new_f (char const *name,  VlPgmImage *im, float** data)
{
  int err = 0 ;
  size_t npixels ;
  vl_uint8 *idata ;

  err = vl_pgm_read_new (name, im, &idata) ;
  if (err) {
    return err ;
  }

  npixels = vl_pgm_get_npixels(im) ;
  *data = vl_malloc (sizeof(float) * npixels) ;
  {
    size_t k ;
    float scale = 1.0f / (float)im->max_value ;
    for (k = 0 ; k < npixels ; ++ k) (*data)[k] = scale * idata[k] ;
  }

  vl_free (idata) ;
  return 0 ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x9110
testl %eax, %eax
jne 0x288da
movq 0x8(%rbx), %r15
imulq (%rbx), %r15
leaq (,%r15,4), %rdi
callq 0x95b0
movq %rax, (%r14)
movq 0x10(%rbx), %rcx
testq %rcx, %rcx
js 0x28885
cvtsi2ss %rcx, %xmm1
jmp 0x2889a
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
testq %r15, %r15
je 0x288ce
movss 0xaaa5(%rip), %xmm0     # 0x3334c
divss %xmm1, %xmm0
movq 0x8(%rsp), %rcx
xorl %edx, %edx
movzbl (%rcx,%rdx), %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x288b2
movq 0x8(%rsp), %rdi
callq 0x9580
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_write
VL_EXPORT
int vl_pgm_write (char const *name, vl_uint8 const* data, int width, int height)
{
  int err = 0 ;
  VlPgmImage pgm ;
  FILE *f = fopen (name, "wb") ;

  if (! f) {
    return vl_set_last_error(VL_ERR_PGM_IO,
             "Error opening PGM file '%s' for writing", name) ;
  }

  pgm.width = width ;
  pgm.height = height ;
  pgm.is_raw = 1 ;
  pgm.max_value = 255 ;

  err = vl_pgm_insert (f, &pgm, data) ;
  fclose (f) ;

  return err ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xb9f9(%rip), %rsi      # 0x342fb
callq 0x97f0
testq %rax, %rax
je 0x28952
movq %rax, %r14
movslq %r12d, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movslq %ebp, %rax
movq %rax, 0x8(%rsi)
movl $0x1, 0x18(%rsi)
movq $0xff, 0x10(%rsi)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x90f0
movl %eax, %ebx
movq %r14, %rdi
callq 0x92a0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb9a5(%rip), %rsi      # 0x342fe
movl $0x68, %edi
movq %r15, %rdx
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9150
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_write_f
VL_EXPORT
int vl_pgm_write_f (char const *name, float const* data, int width, int height)
{
  int err = 0 ;
  int k ;
  float min = + VL_INFINITY_F ;
  float max = - VL_INFINITY_F ;
  float scale ;

  vl_uint8 * buffer = vl_malloc (sizeof(float) * width * height) ;

  for (k = 0 ; k < width * height ; ++k) {
    min = VL_MIN(min, data [k]) ;
    max = VL_MAX(max, data [k]) ;
  }

  scale = 255 / (max - min + VL_EPSILON_F) ;

  for (k = 0 ; k < width * height ; ++k) {
    buffer [k] = (vl_uint8) ((data [k] - min) * scale) ;
  }

  err = vl_pgm_write (name, buffer, width, height) ;

  vl_free (buffer) ;
  return err ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %rax
movslq %ecx, %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x95b0
movq %rax, %r12
movl %ebx, %ecx
imull %ebp, %ecx
movl %ecx, %eax
testl %ecx, %ecx
jle 0x289d1
movss 0xa8e9(%rip), %xmm0     # 0x33298
movss 0xab59(%rip), %xmm1     # 0x33510
xorl %edx, %edx
movss (%r15,%rdx,4), %xmm2
minss %xmm2, %xmm0
maxss %xmm2, %xmm1
incq %rdx
cmpq %rdx, %rax
jne 0x289b9
jmp 0x289e1
movss 0xab37(%rip), %xmm1     # 0x33510
movss 0xa8b7(%rip), %xmm0     # 0x33298
testl %ecx, %ecx
jle 0x28a1d
subss %xmm0, %xmm1
addss 0xa963(%rip), %xmm1     # 0x33354
movss 0xb847(%rip), %xmm2     # 0x34240
divss %xmm1, %xmm2
xorl %ecx, %ecx
movss (%r15,%rcx,4), %xmm1
subss %xmm0, %xmm1
mulss %xmm2, %xmm1
cvttss2si %xmm1, %edx
movb %dl, (%r12,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x289ff
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x93a0
movl %eax, %ebx
movq %r12, %rdi
callq 0x9580
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_new
VL_EXPORT
VlQS *
vl_quickshift_new(vl_qs_type const * image, int height, int width,
                       int channels)
{
  VlQS * q = vl_malloc(sizeof(VlQS));

  q->image    = (vl_qs_type *)image;
  q->height   = height;
  q->width    = width;
  q->channels = channels;

  q->medoid   = VL_FALSE;
  q->tau      = VL_MAX(height,width)/50;
  q->sigma    = VL_MAX(2, q->tau/3);

  q->dists    = vl_calloc(height*width, sizeof(vl_qs_type));
  q->parents  = vl_calloc(height*width, sizeof(int));
  q->density  = vl_calloc(height*width, sizeof(vl_qs_type)) ;

  return q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r12
movl $0x40, %edi
callq 0x95b0
movq %rax, %rbx
movq %r12, (%rax)
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movl %r15d, 0x10(%rax)
movl $0x0, 0x14(%rax)
cmpl %ebp, %r14d
movl %ebp, %eax
cmovgl %r14d, %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x24, %rax
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
divsd 0xa767(%rip), %xmm0     # 0x33210
movsd 0xafc7(%rip), %xmm1     # 0x33a78
maxsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
imull %r14d, %ebp
movslq %ebp, %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x98f0
movq %rax, 0x30(%rbx)
movl $0x4, %esi
movq %r14, %rdi
callq 0x98f0
movq %rax, 0x28(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x98f0
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_delete
void vl_quickshift_delete(VlQS * q)
{
  if (q) {
    if (q->parents) vl_free(q->parents);
    if (q->dists)   vl_free(q->dists);
    if (q->density) vl_free(q->density);

    vl_free(q);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x297c2
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x2979d
callq 0x9580
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x297ab
callq 0x9580
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x297b9
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
retq
nop
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/random.c
// Function: vl_rand_seed
void
vl_rand_seed (VlRand * self, vl_uint32 s)
{
#define mti self->mti
#define mt self->mt
  mt[0]= s & VL_UINT32_C(0xffffffff);
  for (mti=1; mti<N; mti++) {
    mt[mti] =
      (VL_UINT32_C(1812433253) * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
    /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
    /* In the previous versions, MSBs of the seed affect   */
    /* only MSBs of the array mt[].                        */
    /* 2002/01/09 modified by Makoto Matsumoto             */
    mt[mti] &= VL_UINT32_C(0xffffffff);
    /* for >32 bit machines */
  }
#undef mti
#undef mt
}

// Assembly:
movl %esi, (%rdi)
movl $0x1, 0x9c0(%rdi)
movl $0x1, %eax
leal -0x1(%rax), %ecx
movl (%rdi,%rcx,4), %ecx
movl %ecx, %edx
shrl $0x1e, %edx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movl %eax, %eax
movl %ecx, (%rdi,%rax,4)
movl 0x9c0(%rdi), %eax
incl %eax
movl %eax, 0x9c0(%rdi)
cmpl $0x270, %eax            # imm = 0x270
jb 0x297f1
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/random.c
// Function: vl_rand_seed_by_array
void
vl_rand_seed_by_array (VlRand * self, vl_uint32 const key [], vl_size keySize)
{
#define mti self->mti
#define mt self->mt
  int i, j, k;
  vl_rand_seed (self, VL_UINT32_C(19650218));
  i=1; j=0;
  k = (N > keySize ? N : (int)keySize);
  for (; k; k--) {
    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * VL_UINT32_C(1664525)))
      + key[j] + j; /* non linear */
    mt[i] &= VL_UINT32_C(0xffffffff); /* for WORDSIZE > 32 machines */
    i++; j++;
    if (i>=N) { mt[0] = mt[N-1]; i=1; }
    if (j>=(signed)keySize) j=0;
  }
  for (k=N-1; k; k--) {
    mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * VL_UINT32_C(1566083941)))
      - i; /* non linear */
    mt[i] &= VL_UINT32_C(0xffffffff) ; /* for WORDSIZE > 32 machines */
    i++;
    if (i>=N) { mt[0] = mt[N-1]; i=1; }
  }

  mt[0] = VL_UINT32_C(0x80000000); /* MSB is 1; assuring non-zero initial array */
#undef mti
#undef mt
}

// Assembly:
movl $0x12bd6aa, (%rdi)      # imm = 0x12BD6AA
movl $0x1, 0x9c0(%rdi)
movl $0x1, %eax
leal -0x1(%rax), %ecx
movl (%rdi,%rcx,4), %ecx
movl %ecx, %r8d
shrl $0x1e, %r8d
xorl %ecx, %r8d
imull $0x6c078965, %r8d, %ecx # imm = 0x6C078965
addl %eax, %ecx
movl %eax, %eax
movl %ecx, (%rdi,%rax,4)
movl 0x9c0(%rdi), %eax
incl %eax
movl %eax, 0x9c0(%rdi)
cmpl $0x270, %eax            # imm = 0x270
jb 0x29836
cmpq $0x271, %rdx            # imm = 0x271
movl $0x270, %ecx            # imm = 0x270
cmovaeq %rdx, %rcx
testl %ecx, %ecx
je 0x298df
pushq %rbp
pushq %rbx
movl $0x1, %eax
xorl %r8d, %r8d
xorl %r9d, %r9d
movslq %eax, %r10
movl -0x4(%rdi,%r10,4), %r11d
movl %r11d, %ebx
shrl $0x1e, %ebx
xorl %r11d, %ebx
imull $0x19660d, %ebx, %r11d  # imm = 0x19660D
xorl (%rdi,%r10,4), %r11d
movslq %r9d, %rbx
movl (%rsi,%rbx,4), %ebp
addl %ebx, %ebp
addl %r11d, %ebp
movl %ebp, (%rdi,%r10,4)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x298c0
incl %eax
jmp 0x298cd
movl 0x9bc(%rdi), %eax
movl %eax, (%rdi)
movl $0x1, %eax
incl %r9d
cmpl %edx, %r9d
cmovgel %r8d, %r9d
decl %ecx
jne 0x2988a
popq %rbx
popq %rbp
jmp 0x298e4
movl $0x1, %eax
movl $0xfffffd91, %ecx       # imm = 0xFFFFFD91
movslq %eax, %rdx
movl -0x4(%rdi,%rdx,4), %esi
movl %esi, %r8d
shrl $0x1e, %r8d
xorl %esi, %r8d
imull $0x5d588b65, %r8d, %esi # imm = 0x5D588B65
xorl (%rdi,%rdx,4), %esi
subl %edx, %esi
movl %esi, (%rdi,%rdx,4)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x29914
incl %eax
jmp 0x29921
movl 0x9bc(%rdi), %eax
movl %eax, (%rdi)
movl $0x1, %eax
incl %ecx
jne 0x298e9
movl $0x80000000, (%rdi)     # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/random.c
// Function: vl_rand_permute_indexes
void
vl_rand_permute_indexes (VlRand *self, vl_index *array, vl_size size)
{
  vl_index i, j, tmp;
  for (i = size - 1 ; i > 0; i--) {
    /* Pick a random index j in the range 0, i + 1 and swap it with i */
    j = (vl_int) vl_rand_uindex (self, i + 1) ;
    tmp = array[i] ; array[i] = array[j] ; array[j] = tmp ;
  }
}

// Assembly:
leaq -0x1(%rdx), %rax
testq %rax, %rax
jle 0x299a7
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %r13
shrq $0x20, %r13
movq %r15, %rdi
callq 0x9340
movl %eax, %r12d
testq %r13, %r13
jne 0x29967
movl %r12d, %eax
xorl %edx, %edx
divl %ebx
jmp 0x29980
movq %r15, %rdi
callq 0x9340
movl %eax, %eax
shlq $0x20, %r12
orq %rax, %r12
movq %r12, %rax
xorl %edx, %edx
divq %rbx
movq -0x8(%r14,%rbx,8), %rax
movslq %edx, %rcx
movq (%r14,%rcx,8), %rdx
movq %rdx, -0x8(%r14,%rbx,8)
movq %rax, (%r14,%rcx,8)
decq %rbx
cmpq $0x1, %rbx
jg 0x29947
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_get_default_geometry
VlScaleSpaceGeometry
vl_scalespace_get_default_geometry (vl_size width, vl_size height)
{
  VlScaleSpaceGeometry geom ;
  assert(width >= 1) ;
  assert(height >= 1) ;
  geom.width = width ;
  geom.height = height ;
  geom.firstOctave = 0 ;
  geom.lastOctave = VL_MAX(floor(vl_log2_d(VL_MIN(width, height))) - 3, 0) ;
  geom.octaveResolution= 3 ;
  geom.octaveFirstSubdivision = 0 ;
  geom.octaveLastSubdivision = geom.octaveResolution - 1 ;
  geom.baseScale = 1.6 * pow(2.0, 1.0 / geom.octaveResolution) ;
  geom.nominalScale = 0.5 ;
  return geom ;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
cmpq %rdx, %rsi
cmovbq %rsi, %rdx
movq %rdx, %xmm1
punpckldq 0x8935(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x893d(%rip), %xmm1     # 0x33190
movq $0x0, 0x10(%rdi)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
callq 0x9080
callq 0x9880
addsd 0x9b02(%rip), %xmm0     # 0x34380
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2a8a6
movapd (%rsp), %xmm0
callq 0x9080
callq 0x9880
addsd 0x9ae1(%rip), %xmm0     # 0x34380
cvttsd2si %xmm0, %rax
jmp 0x2a8a8
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq $0x3, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movq $0x2, 0x30(%rbx)
movaps 0x9a95(%rip), %xmm0     # 0x34360
movups %xmm0, 0x38(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq