LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x2962e
cmpq $0x271, %rdx            # imm = 0x271
movl $0x270, %ecx            # imm = 0x270
cmovaeq %rdx, %rcx
testl %ecx, %ecx
je 0x296d7
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 0x296b8
incl %eax
jmp 0x296c5
movl 0x9bc(%rdi), %eax
movl %eax, (%rdi)
movl $0x1, %eax
incl %r9d
cmpl %edx, %r9d
cmovgel %r8d, %r9d
decl %ecx
jne 0x29682
popq %rbx
popq %rbp
jmp 0x296dc
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 0x2970c
incl %eax
jmp 0x29719
movl 0x9bc(%rdi), %eax
movl %eax, (%rdi)
movl $0x1, %eax
incl %ecx
jne 0x296e1
movl $0x80000000, (%rdi)     # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2979f
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 0x2975f
movl %r12d, %eax
xorl %edx, %edx
divl %ebx
jmp 0x29778
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
ja 0x2973f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7b61(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x7b69(%rip), %xmm1     # 0x32190
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 0x8d1e(%rip), %xmm0     # 0x33370
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2a67a
movapd (%rsp), %xmm0
callq 0x9080
callq 0x9880
addsd 0x8cfd(%rip), %xmm0     # 0x33370
cvttsd2si %xmm0, %rax
jmp 0x2a67c
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq $0x3, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
movq $0x2, 0x30(%rbx)
movaps 0x8cb1(%rip), %xmm0     # 0x33350
movups %xmm0, 0x38(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespacegeometry_is_equal
vl_bool
vl_scalespacegeometry_is_equal (VlScaleSpaceGeometry a,
                                VlScaleSpaceGeometry b)
{
  return
  a.width == b.width &&
  a.height == b.height &&
  a.firstOctave == b.firstOctave &&
  a.lastOctave == b.lastOctave &&
  a.octaveResolution == b.octaveResolution &&
  a.octaveFirstSubdivision == b.octaveLastSubdivision &&
  a.baseScale == b.baseScale &&
  a.nominalScale == b.nominalScale ;
}

// Assembly:
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x50(%rsp), %rcx
jne 0x2a717
leaq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
cmpq 0x8(%rdx), %rsi
jne 0x2a717
movq 0x10(%rcx), %rsi
cmpq 0x10(%rdx), %rsi
jne 0x2a717
movq 0x18(%rcx), %rsi
cmpq 0x18(%rdx), %rsi
jne 0x2a717
movq 0x20(%rcx), %rsi
cmpq 0x20(%rdx), %rsi
jne 0x2a717
movq 0x28(%rcx), %rsi
cmpq 0x30(%rdx), %rsi
jne 0x2a717
movsd 0x38(%rcx), %xmm0
ucomisd 0x38(%rdx), %xmm0
jne 0x2a717
jp 0x2a717
movsd 0x40(%rdx), %xmm0
cmpeqsd 0x40(%rcx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_get_octave_geometry
VlScaleSpaceOctaveGeometry
vl_scalespace_get_octave_geometry (VlScaleSpace const * self, vl_index o)
{
  VlScaleSpaceOctaveGeometry ogeom ;
  ogeom.width = VL_SHIFT_LEFT(self->geom.width, -o) ;
  ogeom.height = VL_SHIFT_LEFT(self->geom.height, -o) ;
  ogeom.step = pow(2.0, o) ;
  return ogeom ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdx, %rdx
jle 0x2a73e
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movl %edx, %ecx
shrq %cl, %rax
shrq %cl, %rsi
jmp 0x2a74f
movl %edx, %ecx
negb %cl
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
shlq %cl, %rax
shlq %cl, %rsi
movq %rax, (%rbx)
movq %rsi, 0x8(%rbx)
cvtsi2sd %rdx, %xmm0
callq 0x9040
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_get_level
float *
vl_scalespace_get_level (VlScaleSpace *self, vl_index o, vl_index s)
{
  VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
  float * octave ;
  assert(self) ;
  assert(o >= self->geom.firstOctave) ;
  assert(o <= self->geom.lastOctave) ;
  assert(s >= self->geom.octaveFirstSubdivision) ;
  assert(s <= self->geom.octaveLastSubdivision) ;

  octave = self->octaves[o - self->geom.firstOctave] ;
  return octave + ogeom.width * ogeom.height * (s - self->geom.octaveFirstSubdivision) ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
jle 0x2a792
movq (%r15), %r12
movq 0x8(%r15), %rax
movl %r14d, %ecx
shrq %cl, %r12
shrq %cl, %rax
jmp 0x2a7a4
movl %r14d, %ecx
negb %cl
movq (%r15), %r12
movq 0x8(%r15), %rax
shlq %cl, %r12
shlq %cl, %rax
imulq %rax, %r12
cvtsi2sd %r14, %xmm0
callq 0x9040
subq 0x10(%r15), %r14
movq 0x48(%r15), %rax
subq 0x28(%r15), %rbx
imulq %r12, %rbx
shlq $0x2, %rbx
addq (%rax,%r14,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_new_with_geometry
VlScaleSpace *
vl_scalespace_new_with_geometry (VlScaleSpaceGeometry geom)
{

  vl_index o ;
  vl_size numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;
  vl_size numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
  VlScaleSpace *self ;

  assert(is_valid_geometry(geom)) ;
  numOctaves = geom.lastOctave - geom.firstOctave + 1 ;
  numSublevels = geom.octaveLastSubdivision - geom.octaveFirstSubdivision + 1 ;

  self = vl_calloc(1, sizeof(VlScaleSpace)) ;
  if (self == NULL) goto err_alloc_self ;
  self->geom = geom ;
  self->octaves = vl_calloc(numOctaves, sizeof(float*)) ;
  if (self->octaves == NULL) goto err_alloc_octave_list ;
  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
    vl_size octaveSize = ogeom.width * ogeom.height * numSublevels ;
    self->octaves[o - self->geom.firstOctave] = vl_malloc(octaveSize * sizeof(float)) ;
    if (self->octaves[o - self->geom.firstOctave] == NULL) goto err_alloc_octaves;
  }
  return self ;

err_alloc_octaves:
  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
    if (self->octaves[o - self->geom.firstOctave]) {
      vl_free(self->octaves[o - self->geom.firstOctave]) ;
    }
  }
err_alloc_octave_list:
  vl_free(self) ;
err_alloc_self:
  return NULL ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x60(%rsp), %r13
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r14
subq 0x58(%rsp), %r13
movl $0x1, %edi
movl $0x50, %esi
callq 0x98f0
testq %rax, %rax
je 0x2a99a
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
subq %r15, %r14
incq %r14
movl $0x9, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x8, %esi
movq %r14, %rdi
callq 0x98f0
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x2a992
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
jg 0x2a99c
incq %r13
shlq $0x2, %r13
movq %r14, %r15
negq %r15
testq %r14, %r14
jle 0x2a8f8
movq (%rbx), %r12
movq 0x8(%rbx), %rax
movl %r14d, %ecx
shrq %cl, %r12
shrq %cl, %rax
jmp 0x2a908
movq (%rbx), %r12
movq 0x8(%rbx), %rax
movl %r15d, %ecx
shlq %cl, %r12
shlq %cl, %rax
imulq %r13, %r12
imulq %rax, %r12
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
callq 0x9040
movq %r12, %rdi
callq 0x95b0
movq 0x10(%rbx), %r12
movq 0x48(%rbx), %rcx
leaq (,%r12,8), %rdx
subq %rdx, %rcx
movq %rax, (%rcx,%r14,8)
movq 0x48(%rbx), %rax
subq %rdx, %rax
cmpq $0x0, (%rax,%r14,8)
je 0x2a95c
leaq 0x1(%r14), %rax
decq %r15
cmpq 0x18(%rbx), %r14
movq %rax, %r14
jl 0x2a8e1
jmp 0x2a99c
movq 0x18(%rbx), %rax
cmpq %rax, %r12
jg 0x2a992
decq %r12
movq 0x10(%rbx), %rcx
movq 0x48(%rbx), %rdx
shlq $0x3, %rcx
subq %rcx, %rdx
movq 0x8(%rdx,%r12,8), %rdi
testq %rdi, %rdi
je 0x2a98a
callq 0x9580
movq 0x18(%rbx), %rax
incq %r12
cmpq %rax, %r12
jl 0x2a968
movq %rbx, %rdi
callq 0x9580
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_new_copy
VlScaleSpace *
vl_scalespace_new_copy (VlScaleSpace* self)
{
  vl_index o  ;
  VlScaleSpace * copy = vl_scalespace_new_shallow_copy(self) ;
  if (copy == NULL) return NULL ;

  for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
    VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self,o) ;
    vl_size numSubevels = self->geom.octaveLastSubdivision - self->geom.octaveFirstSubdivision + 1;
    memcpy(copy->octaves[o - self->geom.firstOctave],
           self->octaves[o - self->geom.firstOctave],
           ogeom.width * ogeom.height * numSubevels * sizeof(float)) ;
  }
  return copy ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl $0x9, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x98b0
movq %rax, %r14
testq %rax, %rax
je 0x2aa6a
movq 0x10(%rbx), %r15
cmpq 0x18(%rbx), %r15
jg 0x2aa6a
movq %r15, %r12
negq %r12
testq %r15, %r15
jle 0x2aa03
movq (%rbx), %r13
movq 0x8(%rbx), %rax
movl %r15d, %ecx
shrq %cl, %r13
shrq %cl, %rax
jmp 0x2aa13
movq (%rbx), %r13
movq 0x8(%rbx), %rax
movl %r12d, %ecx
shlq %cl, %r13
shlq %cl, %rax
imulq %rax, %r13
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
callq 0x9040
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rdx
subq 0x28(%rbx), %rdx
incq %rdx
imulq %r13, %rdx
movq 0x48(%r14), %rcx
shlq $0x3, %rax
subq %rax, %rcx
movq (%rcx,%r15,8), %rdi
movq 0x48(%rbx), %rcx
subq %rax, %rcx
movq (%rcx,%r15,8), %rsi
shlq $0x2, %rdx
callq 0x95a0
leaq 0x1(%r15), %rax
decq %r12
cmpq 0x18(%rbx), %r15
movq %rax, %r15
jl 0x2a9ec
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_delete
void
vl_scalespace_delete (VlScaleSpace * self)
{
  if (self) {
    if (self->octaves) {
      vl_index o ;
      for (o = self->geom.firstOctave ; o <= self->geom.lastOctave ; ++o) {
        if (self->octaves[o - self->geom.firstOctave]) {
          vl_free(self->octaves[o - self->geom.firstOctave]) ;
        }
      }
      vl_free(self->octaves) ;
    }
    vl_free(self) ;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2aafe
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x2aaef
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %rax
cmpq %rax, %r14
jg 0x2aaea
decq %r14
movq 0x10(%rbx), %rcx
movq 0x48(%rbx), %rdx
shlq $0x3, %rcx
subq %rcx, %rdx
movq 0x8(%rdx,%r14,8), %rdi
testq %rdi, %rdi
je 0x2aade
callq 0x9580
movq 0x18(%rbx), %rax
incq %r14
cmpq %rax, %r14
jl 0x2aabc
movq 0x48(%rbx), %rdi
callq 0x9580
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_fill_octave
void
_vl_scalespace_fill_octave (VlScaleSpace *self, vl_index o)
{
  vl_index s ;
  VlScaleSpaceOctaveGeometry ogeom = vl_scalespace_get_octave_geometry(self, o) ;

  for(s = self->geom.octaveFirstSubdivision + 1 ;
      s <= self->geom.octaveLastSubdivision ; ++s) {
    double sigma = vl_scalespace_get_level_sigma(self, o, s) ;
    double previousSigma = vl_scalespace_get_level_sigma(self, o, s - 1) ;
    double deltaSigma = sqrtf(sigma*sigma - previousSigma*previousSigma) ;

    float* level = vl_scalespace_get_level (self, o, s) ;
    float* previous = vl_scalespace_get_level (self, o, s-1) ;
    vl_imsmooth_f (level, ogeom.width,
                   previous, ogeom.width, ogeom.height, ogeom.width,
                   deltaSigma / ogeom.step, deltaSigma / ogeom.step) ;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
jle 0x2ab29
movq (%r14), %r15
movq 0x8(%r14), %rax
movl %ebx, %ecx
shrq %cl, %r15
shrq %cl, %rax
jmp 0x2ab3a
movl %ebx, %ecx
negb %cl
movq (%r14), %r15
movq 0x8(%r14), %rax
shlq %cl, %r15
shlq %cl, %rax
movq %rax, 0x8(%rsp)
cvtsi2sd %rbx, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x9040
movsd %xmm0, 0x18(%rsp)
movq 0x28(%r14), %rbp
cmpq 0x30(%r14), %rbp
jge 0x2ac8f
leaq 0x1(%rbp), %r13
movsd 0x38(%r14), %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r13, %xmm0
movsd 0x20(%r14), %xmm1
movsd 0x75f8(%rip), %xmm2     # 0x32180
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x75fd(%rip), %xmm2     # 0x32190
subpd %xmm2, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addsd 0x10(%rsp), %xmm0
callq 0x9040
mulsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x38(%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rbp, %xmm0
movsd 0x20(%r14), %xmm1
unpcklps 0x75a3(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x75ab(%rip), %xmm1     # 0x32190
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addsd 0x10(%rsp), %xmm0
callq 0x9040
mulsd 0x20(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
ucomiss 0x7763(%rip), %xmm0     # 0x32388
jb 0x2ac2d
sqrtss %xmm0, %xmm0
jmp 0x2ac32
callq 0x95e0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x9050
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x9050
movsd (%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq 0x8(%rsp), %r8
movq %r15, %r9
movapd %xmm0, %xmm1
callq 0x9770
movq %r13, %rbp
cmpq 0x30(%r14), %r13
jl 0x2ab63
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/sift.c
// Function: vl_sift_delete
VL_EXPORT
void
vl_sift_delete (VlSiftFilt* f)
{
  if (f) {
    if (f->keys) vl_free (f->keys) ;
    if (f->grad) vl_free (f->grad) ;
    if (f->dog) vl_free (f->dog) ;
    if (f->octave) vl_free (f->octave) ;
    if (f->temp) vl_free (f->temp) ;
    if (f->gaussFilter) vl_free (f->gaussFilter) ;
    vl_free (f) ;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2b551
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x2b4ff
callq 0x9580
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x2b510
callq 0x9580
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2b51e
callq 0x9580
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2b52c
callq 0x9580
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2b53a
callq 0x9580
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2b548
callq 0x9580
movq %rbx, %rdi
popq %rbx
jmp 0x9580
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/sift.c
// Function: copy_and_upsample_rows
static void
copy_and_upsample_rows
(vl_sift_pix       *dst,
 vl_sift_pix const *src, int width, int height)
{
  int x, y ;
  vl_sift_pix a, b ;

  for(y = 0 ; y < height ; ++y) {
    b = a = *src++ ;
    for(x = 0 ; x < width - 1 ; ++x) {
      b = *src++ ;
      *dst = a ;             dst += height ;
      *dst = 0.5 * (a + b) ; dst += height ;
      a = b ;
    }
    *dst = b ; dst += height ;
    *dst = b ; dst += height ;
    dst += 1 - width * 2 * height ;
  }
}

// Assembly:
testl %ecx, %ecx
jle 0x2b8d7
pushq %rbx
movl %edx, %r8d
imull %ecx, %r8d
movl %ecx, %eax
addl %r8d, %r8d
movl $0x1, %r9d
subl %r8d, %r9d
movslq %r9d, %r8
leal -0x1(%rdx), %r9d
leaq (,%rax,8), %r10
xorl %r11d, %r11d
movss 0x6ae1(%rip), %xmm0     # 0x32360
leaq 0x4(%rsi), %rbx
movss (%rsi), %xmm2
cmpl $0x2, %edx
jl 0x2b8b4
movl %r9d, %esi
movss (%rbx), %xmm1
movss %xmm2, (%rdi)
addss %xmm1, %xmm2
mulss %xmm0, %xmm2
movss %xmm2, (%rdi,%rax,4)
addq $0x4, %rbx
addq %r10, %rdi
movaps %xmm1, %xmm2
decl %esi
jne 0x2b88f
jmp 0x2b8b7
movaps %xmm2, %xmm1
movss %xmm1, (%rdi)
leaq (%rdi,%rax,4), %rsi
movss %xmm1, (%rsi)
leaq (%rsi,%rax,4), %rsi
leaq (%rsi,%r8,4), %rdi
incl %r11d
movq %rbx, %rsi
cmpl %ecx, %r11d
jne 0x2b87f
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/sift.c
// Function: vl_sift_keypoint_init
VL_EXPORT
void
vl_sift_keypoint_init (VlSiftFilt const *f,
                       VlSiftKeypoint *k,
                       double x,
                       double y,
                       double sigma)
{
  int    o, ix, iy, is ;
  double s, phi, xper ;

  phi = log2 ((sigma + VL_EPSILON_D) / f->sigma0) ;
  o   = (int)vl_floor_d (phi -  ((double) f->s_min + 0.5) / f->S) ;
  o   = VL_MIN (o, f->o_min + f->O - 1) ;
  o   = VL_MAX (o, f->o_min           ) ;
  s   = f->S * (phi - o) ;

  is  = (int)(s + 0.5) ;
  is  = VL_MIN(is, f->s_max - 2) ;
  is  = VL_MAX(is, f->s_min + 1) ;

  xper = pow (2.0, o) ;
  ix   = (int)(x / xper + 0.5) ;
  iy   = (int)(y / xper + 0.5) ;

  k -> o  = o ;

  k -> ix = ix ;
  k -> iy = iy ;
  k -> is = is ;

  k -> x = x ;
  k -> y = y ;
  k -> s = s ;

  k->sigma = sigma ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movapd %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movsd 0x3acb(%rip), %xmm0     # 0x32bc8
addsd %xmm2, %xmm0
divsd 0x8(%rdi), %xmm0
callq 0x9430
divsd 0x4265(%rip), %xmm0     # 0x33378
movl 0x34(%r15), %ebp
xorps %xmm2, %xmm2
cvtsi2sd %ebp, %xmm2
movsd 0x30ba(%rip), %xmm5     # 0x321e0
xorps %xmm1, %xmm1
cvtsi2sdl 0x2c(%r15), %xmm1
addsd %xmm5, %xmm2
divsd %xmm1, %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
cvttsd2si %xmm3, %r14
xorps %xmm2, %xmm2
cvtsi2sd %r14, %xmm2
cmpneqpd %xmm3, %xmm2
xorpd %xmm4, %xmm4
cmpnlepd %xmm3, %xmm4
andpd %xmm2, %xmm4
movd %xmm4, %eax
addl %eax, %r14d
movl 0x28(%r15), %eax
movl 0x30(%r15), %ecx
addl %ecx, %eax
decl %eax
cmpl %r14d, %eax
cmovll %eax, %r14d
cmpl %ecx, %r14d
cmovlel %ecx, %r14d
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
subsd %xmm2, %xmm0
mulsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
addsd %xmm0, %xmm5
cvttsd2si %xmm5, %eax
movl 0x38(%r15), %ecx
addl $-0x2, %ecx
cmpl %eax, %ecx
cmovgel %eax, %ecx
incl %ebp
cmpl %ebp, %ecx
cmovgl %ecx, %ebp
movsd 0x30b9(%rip), %xmm0     # 0x32270
movl %r14d, %edi
callq 0x90c0
movapd 0x10(%rsp), %xmm2
unpcklpd 0x20(%rsp), %xmm2       # xmm2 = xmm2[0],mem[0]
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
cvtpd2ps %xmm2, %xmm1
divpd %xmm0, %xmm2
addpd 0x2f11(%rip), %xmm2     # 0x320f0
cvttpd2dq %xmm2, %xmm0
movl %r14d, (%rbx)
movlpd %xmm0, 0x4(%rbx)
movl %ebp, 0xc(%rbx)
movapd (%rsp), %xmm0
unpcklpd 0x30(%rsp), %xmm0       # xmm0 = xmm0[0],mem[0]
cvtpd2ps %xmm0, %xmm0
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movupd %xmm1, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_string_parse_protocol
VL_EXPORT char *
vl_string_parse_protocol (char const *string, int *protocol)
{
  char const * cpt ;
  int dummy ;

  /* handle the case prot = 0 */
  if (protocol == 0)
    protocol = &dummy ;

  /* look for :// */
  cpt = strstr(string, "://") ;

  if (cpt == 0) {
    *protocol = VL_PROT_NONE ;
    cpt = string ;
  }
  else {
    if (strncmp(string, "ascii", cpt - string) == 0) {
      *protocol = VL_PROT_ASCII ;
    }
    else if (strncmp(string, "bin",   cpt - string) == 0) {
      *protocol = VL_PROT_BINARY ;
    }
    else {
      *protocol = VL_PROT_UNKNOWN ;
    }
    cpt += 3 ;
  }
  return (char*) cpt ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x364f(%rip), %rsi      # 0x33490
callq 0x9a30
testq %rax, %rax
je 0x2fe8c
movq %rax, %r14
movq %rax, %r12
subq %r15, %r12
leaq 0x3639(%rip), %rsi      # 0x33494
movq %r15, %rdi
movq %r12, %rdx
callq 0x90e0
testl %eax, %eax
je 0x2fe99
leaq 0x3629(%rip), %rsi      # 0x3349a
movq %r15, %rdi
movq %r12, %rdx
callq 0x90e0
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
testq %rbx, %rbx
je 0x2fea5
orl $0x2, %ecx
jmp 0x2fea3
testq %rbx, %rbx
je 0x2feac
movl $0x0, (%rbx)
jmp 0x2feac
movl $0x1, %ecx
testq %rbx, %rbx
je 0x2fea5
movl %ecx, (%rbx)
addq $0x3, %r14
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_string_basename
VL_EXPORT vl_size
vl_string_basename (char * destination,
                    vl_size destinationSize,
                    char const * source,
                    vl_size maxNumStrippedExtensions)
{
  char c ;
  vl_uindex k = 0, beg, end ;

  /* find beginning */
  beg = 0 ;
  for (k = 0 ; (c = source[k]) ; ++ k) {
    if (c == '\\' || c == '/') beg = k + 1 ;
  }

  /* find ending */
  end = strlen (source) ;
  for (k = end ; k > beg ; --k) {
    if (source[k - 1] == '.' && maxNumStrippedExtensions > 0) {
      -- maxNumStrippedExtensions ;
      end = k - 1 ;
    }
  }

  return vl_string_copy_sub (destination, destinationSize,
                             source + beg, source + end) ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x1(%r13), %rax
movzbl -0x1(%r15,%rax), %ecx
testl %ecx, %ecx
je 0x2ff0e
cmpl $0x2f, %ecx
je 0x2ff09
cmpl $0x5c, %ecx
je 0x2ff09
incq %rax
jmp 0x2fef0
movq %rax, %r13
jmp 0x2feec
movq %r15, %rdi
callq 0x9310
cmpq %r13, %rax
jbe 0x2ff4a
movq %rax, %rcx
cmpb $0x2e, -0x1(%r15,%rcx)
leaq -0x1(%rcx), %rdx
sete %cl
testq %r12, %r12
setne %sil
andb %cl, %sil
movzbl %sil, %ecx
subq %rcx, %r12
testb %cl, %cl
cmovneq %rdx, %rax
movq %rdx, %rcx
cmpq %r13, %rdx
ja 0x2ff1e
subq %r13, %rax
jle 0x2ff88
addq %r13, %r15
xorl %ecx, %ecx
movb (%r15,%rcx), %dl
testb %dl, %dl
je 0x2ff8a
testq %r14, %r14
setne %dil
leaq 0x1(%rcx), %rsi
cmpq %rbx, %rsi
setb %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x2ff7b
movb %dl, (%r14,%rcx)
movq %rsi, %rcx
cmpq %rsi, %rax
jne 0x2ff54
movq %rax, %rcx
jmp 0x2ff8a
xorl %ecx, %ecx
testq %rbx, %rbx
je 0x2ff9e
decq %rbx
cmpq %rbx, %rcx
cmovbq %rcx, %rbx
movb $0x0, (%r14,%rbx)
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_string_copy_sub
VL_EXPORT vl_size
vl_string_copy_sub (char * destination,
                    vl_size destinationSize,
                    char const * beginning,
                    char const * end)
{
  char c ;
  vl_uindex k = 0 ;

  while (beginning < end && (c = *beginning++)) {
    if (destination && k + 1 < destinationSize) {
      destination[k] = c ;
    }
    ++ k ;
  }

  /* finalize */
  if (destinationSize > 0) {
    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
  }
  return  k ;
}

// Assembly:
cmpq %rcx, %rdx
jae 0x2ffea
subq %rdx, %rcx
xorl %eax, %eax
movb (%rdx,%rax), %r8b
testb %r8b, %r8b
je 0x2ffec
testq %rdi, %rdi
setne %r10b
leaq 0x1(%rax), %r9
cmpq %rsi, %r9
setb %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x2ffdd
movb %r8b, (%rdi,%rax)
movq %r9, %rax
cmpq %r9, %rcx
jne 0x2ffb5
movq %rcx, %rax
jmp 0x2ffec
xorl %eax, %eax
testq %rsi, %rsi
je 0x2ffff
decq %rsi
cmpq %rsi, %rax
cmovbq %rax, %rsi
movb $0x0, (%rdi,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_string_replace_wildcard
VL_EXPORT vl_size
vl_string_replace_wildcard (char * destination,
                            vl_size destinationSize,
                            char const * source,
                            char wildcardChar,
                            char escapeChar,
                            char const * replacement)
{
  char c ;
  vl_uindex k = 0 ;
  vl_bool escape = 0 ;

  while ((c = *source++)) {

    /* enter escape mode ? */
    if (! escape && c == escapeChar) {
      escape = 1 ;
      continue ;
    }

    /* wildcard or regular? */
    if (! escape && c == wildcardChar) {
      char const * repl = replacement ;
      while ((c = *repl++)) {
        if (destination && k + 1 < destinationSize) {
          destination[k] = c ;
        }
        ++ k ;
      }
    }
    /* regular character */
    else {
      if (destination && k + 1 < destinationSize) {
        destination[k] = c ;
      }
      ++ k ;
    }
    escape = 0 ;
  }

  /* add trailing 0 */
  if (destinationSize > 0) {
    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
  }
  return  k ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1(%r9), %r10
xorl %r11d, %r11d
movq %r11, %rax
movb $0x1, %bpl
movb (%rdx), %bl
testb %bl, %bl
je 0x300a4
movl %ebp, %r11d
incq %rdx
cmpb %r8b, %bl
sete %r14b
xorl %ebp, %ebp
testb %r14b, %r11b
jne 0x30013
cmpb %cl, %bl
setne %bpl
notb %r11b
orb %bpl, %r11b
testb $0x1, %r11b
jne 0x3007d
movb (%r9), %bl
movq %rax, %r11
testb %bl, %bl
je 0x3000d
movq %r10, %r14
testq %rdi, %rdi
setne %bpl
leaq 0x1(%rax), %r11
cmpq %rsi, %r11
setb %r15b
andb %bpl, %r15b
cmpb $0x1, %r15b
jne 0x3006e
movb %bl, (%rdi,%rax)
movb (%r14), %bl
incq %r14
movq %r11, %rax
testb %bl, %bl
jne 0x30050
jmp 0x3000d
testq %rdi, %rdi
setne %bpl
leaq 0x1(%rax), %r11
cmpq %rsi, %r11
setb %r14b
andb %bpl, %r14b
cmpb $0x1, %r14b
jne 0x3000d
movb %bl, (%rdi,%rax)
jmp 0x3000d
testq %rsi, %rsi
je 0x300b7
decq %rsi
cmpq %rsi, %rax
cmovbq %rax, %rsi
movb $0x0, (%rdi,%rsi)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_string_copy
VL_EXPORT vl_size
vl_string_copy (char * destination, vl_size destinationSize,
                char const * source)
{
  char c ;
  vl_uindex k = 0 ;

  while ((c = *source++)) {
    if (destination && k + 1 < destinationSize) {
      destination[k] = c ;
    }
    ++ k ;
  }

  /* finalize */
  if (destinationSize > 0) {
    destination[VL_MIN(k, destinationSize - 1)] = 0 ;
  }
  return  k ;
}

// Assembly:
movb (%rdx), %cl
testb %cl, %cl
je 0x300f4
xorl %r8d, %r8d
testq %rdi, %rdi
setne %r9b
leaq 0x1(%r8), %rax
cmpq %rsi, %rax
setb %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x300e6
movb %cl, (%rdi,%r8)
movb 0x1(%rdx,%r8), %cl
movq %rax, %r8
testb %cl, %cl
jne 0x300c7
jmp 0x300f6
xorl %eax, %eax
testq %rsi, %rsi
je 0x30109
decq %rsi
cmpq %rsi, %rax
cmovbq %rax, %rsi
movb $0x0, (%rdi,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_string_casei_cmp
VL_EXPORT int
vl_string_casei_cmp (const char * string1, const char * string2)
{
  while (tolower((char unsigned)*string1) ==
         tolower((char unsigned)*string2))
  {
    if (*string1 == 0) {
      return 0 ;
    }
    string1 ++ ;
    string2 ++ ;
  }
  return
    (int)tolower((char unsigned)*string1) -
    (int)tolower((char unsigned)*string2) ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9aa0
movq (%rax), %rcx
movzbl (%r14), %edx
movl (%rcx,%rdx,4), %eax
movzbl (%rbx), %esi
movl (%rcx,%rsi,4), %edi
cmpl %edi, %eax
jne 0x30174
movl $0x1, %esi
testb %dl, %dl
je 0x30178
movzbl (%r14,%rsi), %edx
movl (%rcx,%rdx,4), %eax
movzbl (%rbx,%rsi), %edi
movl (%rcx,%rdi,4), %edi
incq %rsi
cmpl %edi, %eax
je 0x3015a
subl %edi, %eax
jmp 0x3017a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_enumeration_get
VL_EXPORT VlEnumerator *
vl_enumeration_get (VlEnumerator const *enumeration, char const *name)
{
  assert(enumeration) ;
  while (enumeration->name) {
    if (strcmp(name, enumeration->name) == 0) return (VlEnumerator*)enumeration ;
    enumeration ++ ;
  }
  return NULL ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x301ad
movq %rdi, %rbx
movq %r14, %rdi
callq 0x9510
testl %eax, %eax
je 0x301af
movq 0x10(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x30194
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_enumeration_get_casei
VL_EXPORT VlEnumerator *
vl_enumeration_get_casei (VlEnumerator const *enumeration, char const *name)
{
  assert(enumeration) ;
  while (enumeration->name) {
    if (vl_string_casei_cmp(name, enumeration->name) == 0) return (VlEnumerator*)enumeration ;
    enumeration ++ ;
  }
  return NULL ;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x301e5
movq %rdi, %rbx
movq %r14, %rdi
callq 0x9a20
testl %eax, %eax
je 0x301e7
movq 0x10(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x301cc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/stringop.c
// Function: vl_enumeration_get_by_value
VL_EXPORT VlEnumerator *
vl_enumeration_get_by_value (VlEnumerator const *enumeration, vl_index value)
{
  assert(enumeration) ;
  while (enumeration->name) {
    if (enumeration->value == value) return (VlEnumerator*)enumeration ;
    enumeration ++ ;
  }
  return NULL ;
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x3020c
movq %rdi, %rax
cmpq %rsi, 0x8(%rax)
je 0x3020e
cmpq $0x0, 0x10(%rax)
leaq 0x10(%rax), %rax
jne 0x301fb
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svm.c
// Function: vl_svm_delete
void
vl_svm_delete (VlSvm * self)
{
  if (self->model) {
    vl_free (self->model) ;
    self->model = 0 ;
  }
  if (self->alpha) {
    vl_free (self->alpha) ;
    self->alpha = 0 ;
  }
  if (self->ownDataset) {
    vl_svmdataset_delete(self->ownDataset) ;
    self->ownDataset = 0 ;
  }
  vl_free (self) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x305a7
callq 0x9580
movq $0x0, 0x10(%rbx)
movq 0x120(%rbx), %rdi
testq %rdi, %rdi
je 0x305c3
callq 0x9580
movq $0x0, 0x120(%rbx)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x305d9
callq 0x90a0
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svm.c
// Function: vl_svm_l1_dca_update
double
vl_svm_l1_dca_update (double alpha, double inner, double norm2, double label) {
  if (vl_abs_d(alpha) <= 1) {
    double palpha = (label - inner) / norm2 + alpha ;
    return VL_MAX(-1.0, VL_MIN(1.0, palpha)) - alpha ;
  } else {
    return VL_INFINITY_D ;
  }
}

// Assembly:
movapd 0x18cd(%rip), %xmm5     # 0x32100
andpd %xmm0, %xmm5
movsd 0x1a31(%rip), %xmm4     # 0x32270
ucomisd %xmm5, %xmm4
jae 0x3084f
movsd 0x23bb(%rip), %xmm1     # 0x32c08
jmp 0x3086f
subsd %xmm1, %xmm3
divsd %xmm2, %xmm3
addsd %xmm0, %xmm3
minsd %xmm3, %xmm4
movsd 0x19a1(%rip), %xmm1     # 0x32208
maxsd %xmm4, %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svm.c
// Function: vl_svm_logistic_loss
double
vl_svm_logistic_loss (double inner,double label)
{
  double z = label * inner ;
  if (z >= 0) {
    return log(1.0 + exp(-z)) ;
  } else {
    return -z + log(exp(z) + 1.0) ;
  }
}

// Assembly:
subq $0x18, %rsp
mulsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x308f7
movapd %xmm0, (%rsp)
callq 0x9a60
addsd 0x1988(%rip), %xmm0     # 0x32270
callq 0x9430
subsd (%rsp), %xmm0
addq $0x18, %rsp
retq
xorpd 0x17d1(%rip), %xmm0     # 0x320d0
callq 0x9a60
addsd 0x1964(%rip), %xmm0     # 0x32270
addq $0x18, %rsp
jmp 0x9430
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svm.c
// Function: vl_svm_logistic_conjugate_loss
double
vl_svm_logistic_conjugate_loss (double u, double label) {
  double z = label * u ;
  if (-1 <= z && z <= 0) {
    return xlogx(-z) + xlogx(1+z) ;
  } else {
    return VL_INFINITY_D ;
  }
}

// Assembly:
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
ucomisd 0x189f(%rip), %xmm2     # 0x32208
movsd 0x2297(%rip), %xmm0     # 0x32c08
jb 0x309ff
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
jb 0x309ff
subq $0x28, %rsp
ucomisd 0x2b33(%rip), %xmm2     # 0x334c0
jae 0x309ba
movapd 0x1739(%rip), %xmm0     # 0x320d0
xorpd %xmm2, %xmm0
movapd %xmm0, (%rsp)
movapd %xmm2, 0x10(%rsp)
callq 0x9430
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
mulsd (%rsp), %xmm3
addsd 0x18ae(%rip), %xmm2     # 0x32270
xorpd %xmm0, %xmm0
movsd 0x1fda(%rip), %xmm1     # 0x329a8
ucomisd %xmm2, %xmm1
jae 0x309f3
movapd %xmm2, %xmm0
movapd %xmm2, 0x10(%rsp)
movsd %xmm3, (%rsp)
callq 0x9430
movsd (%rsp), %xmm3
mulsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm3
movapd %xmm3, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svm.c
// Function: vl_svm_evaluate
void _vl_svm_evaluate (VlSvm *self)
{
  double startTime = vl_get_cpu_time () ;

  _vl_svm_update_statistics (self) ;

  self->statistics.elapsedTime = vl_get_cpu_time() - startTime ;
  self->statistics.iteration = 0 ;
  self->statistics.epoch = 0 ;
  self->statistics.status = VlSvmStatusConverged ;

  if (self->diagnosticFn) {
    self->diagnosticFn(self, self->diagnosticFnData) ;
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x9350
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x30bc3
callq 0x9350
subsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x108(%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0xc0(%rbx)
movl $0x2, 0xb8(%rbx)
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x30e1c
movq 0x60(%rbx), %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmpq *%rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_inner_product_f
double
VL_XCAT(_vl_svmdataset_inner_product_,SFX) (VlSvmDataset const *self,
                                            vl_uindex element,
                                            double const *model)
{
  double product = 0 ;
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  while (data != end) {
    product += (*data++) * (*model++) ;
  }
  return product ;
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x3153e
imulq %rax, %rsi
shlq $0x2, %rsi
addq 0x8(%rdi), %rsi
shlq $0x2, %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtss2sd (%rsi,%rcx), %xmm1
mulsd (%rdx,%rcx,2), %xmm1
addsd %xmm1, %xmm0
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x31523
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_accumulate_f
void
VL_XCAT(vl_svmdataset_accumulate_,SFX)(VlSvmDataset const *self,
                                       vl_uindex element,
                                       double *model,
                                       const double multiplier)
{
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  while (data != end) {
    *model += (*data++) * multiplier ;
    model++ ;
  }
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x3157c
imulq %rax, %rsi
shlq $0x2, %rsi
addq 0x8(%rdi), %rsi
shlq $0x2, %rax
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtss2sd (%rsi,%rcx), %xmm1
mulsd %xmm0, %xmm1
addsd (%rdx,%rcx,2), %xmm1
movsd %xmm1, (%rdx,%rcx,2)
addq $0x4, %rcx
cmpq %rcx, %rax
jne 0x3155d
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_inner_product_hom_f
double
VL_XCAT(_vl_svmdataset_inner_product_hom_,SFX) (VlSvmDataset const *self,
                                                vl_uindex element,
                                                double const *model)
{
  double product = 0 ;
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
  while (data != end) {
    /* TODO: zeros in data could be optimized by skipping over them */
    T* buf = self->homBuffer ;
    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
                                                   self->homBuffer,
                                                   1,
                                                   (*data++)) ;
    while (buf != bufEnd) {
      product += (*buf++) * (*model++) ;
    }
  }
  return product ;
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x31627
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %r13
imulq %rax, %r14
shlq $0x2, %r14
addq 0x8(%rdi), %r14
leaq (%r14,%rax,4), %rbp
shlq $0x2, %r13
addq 0x28(%rdi), %r13
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%r15), %rdi
movq 0x28(%r15), %r12
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
movl $0x1, %edx
movq %r12, %rsi
callq 0x9690
cmpq %r13, %r12
je 0x3160a
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd (%r12), %xmm1
mulsd (%rbx), %xmm1
addq $0x4, %r12
addq $0x8, %rbx
addsd %xmm1, %xmm0
cmpq %r13, %r12
jne 0x315ea
jmp 0x3160f
movsd (%rsp), %xmm0
addq $0x4, %r14
cmpq %rbp, %r14
jne 0x315be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_accumulate_hom_f
void
VL_XCAT(vl_svmdataset_accumulate_hom_,SFX)(VlSvmDataset const *self,
                                           vl_uindex element,
                                           double *model,
                                           const double multiplier)
{
  T* data = ((T*)self->data) + self->dimension * element ;
  T* end = data + self->dimension ;
  T* bufEnd = ((T*)self->homBuffer)+ self->homDimension ;
  while (data != end) {
    /* TODO: zeros in data could be optimized by skipping over them */
    T* buf = self->homBuffer ;
    VL_XCAT(vl_homogeneouskernelmap_evaluate_,SFX)(self->hom,
                                                   self->homBuffer,
                                                   1,
                                                   (*data++)) ;
    while (buf != bufEnd) {
      *model += (*buf++) * multiplier ;
      model++ ;
    }
  }
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x316cd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rdi), %r13
imulq %rax, %r14
shlq $0x2, %r14
addq 0x8(%rdi), %r14
leaq (%r14,%rax,4), %rbp
shlq $0x2, %r13
addq 0x28(%rdi), %r13
movsd %xmm0, (%rsp)
movq 0x20(%r15), %rdi
movq 0x28(%r15), %r12
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
movl $0x1, %edx
movq %r12, %rsi
callq 0x9690
cmpq %r13, %r12
je 0x316b6
movsd (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd (%r12), %xmm1
mulsd %xmm0, %xmm1
addsd (%rbx), %xmm1
addq $0x4, %r12
movsd %xmm1, (%rbx)
addq $0x8, %rbx
cmpq %r13, %r12
jne 0x31694
addq $0x4, %r14
cmpq %rbp, %r14
jne 0x3166d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_new
VlSvmDataset*
vl_svmdataset_new (vl_type dataType, void *data, vl_size dimension, vl_size numData)
{
  VlSvmDataset * self ;
  assert(dataType == VL_TYPE_DOUBLE || dataType == VL_TYPE_FLOAT) ;
  assert(data) ;

  self = vl_calloc(1, sizeof(VlSvmDataset)) ;
  if (self == NULL) return NULL ;

  self->dataType = dataType ;
  self->data = data ;
  self->dimension = dimension ;
  self->numData = numData ;
  self->hom = NULL ;
  self->homBuffer = NULL ;
  return self ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movl $0x1, %edi
movl $0x38, %esi
callq 0x98f0
testq %rax, %rax
je 0x318c1
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_delete
void vl_svmdataset_delete (VlSvmDataset *self)
{
  if (self->homBuffer) {
    vl_free(self->homBuffer) ;
    self->homBuffer = 0 ;
  }
  vl_free (self) ;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x318e6
callq 0x9580
movq $0x0, 0x28(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x9580
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/vl/svmdataset.c
// Function: vl_svmdataset_set_homogeneous_kernel_map
void
vl_svmdataset_set_homogeneous_kernel_map (VlSvmDataset * self,
                                          VlHomogeneousKernelMap * hom)
{
  assert(self) ;
  self->hom = hom ;
  self->homDimension = 0 ;
  if (self->homBuffer) {
    vl_free (self->homBuffer) ;
    self->homBuffer = 0 ;
  }
  if (self->hom) {
    self->homDimension = vl_homogeneouskernelmap_get_dimension(self->hom) ;
    self->homBuffer = vl_calloc(self->homDimension, vl_get_type_size(self->dataType)) ;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x20(%rdi)
movq $0x0, 0x30(%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x31944
callq 0x9580
movq $0x0, 0x28(%rbx)
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x31977
movq %rsi, %rdi
callq 0x99a0
movq %rax, 0x30(%rbx)
movl (%rbx), %ecx
decl %ecx
cmpl $0xa, %ecx
jae 0x31979
movl %ecx, %ecx
leaq 0x1b69(%rip), %rdx      # 0x334d0
movq (%rdx,%rcx,8), %rsi
movq %rax, %rdi
callq 0x98f0
movq %rax, 0x28(%rbx)
popq %rbx
retq
callq 0x90b0
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/number.c
// Function: test_prime
void test_prime(const char *s)
{
	struct tt_int *ti = tt_int_alloc();
	tt_int_from_string(ti, s);

	if (tt_int_isprime(ti))
		printf("Prime: ");
	else
		printf("Composite: ");
	printf("%s\n", s);

	tt_int_free(ti);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4910
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4dbc
movq %r14, %rdi
callq 0x8bbe
leaq 0x93cb(%rip), %rcx      # 0xb020
leaq 0x93cc(%rip), %rdi      # 0xb028
testb %al, %al
cmovneq %rcx, %rdi
xorl %eax, %eax
callq 0x10c0
movq %rbx, %rdi
callq 0x1060
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4970
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/number.c
// Function: nth_prime
void nth_prime(uint n)
{
	printf("%d-th prime: ", n);

	if (n == 1) {
		printf("2\n");
		return;
	}

	struct tt_int *ti = tt_int_alloc();
	struct tt_int *two = tt_int_alloc();
	tt_int_from_uint(ti, 1);
	tt_int_from_uint(two, 2);

	while (--n) {
		tt_int_add(ti, ti, two);
		while (!tt_int_isprime(ti))
			tt_int_add(ti, ti, two);
	}

	char *s = NULL;
	tt_int_to_string(ti, &s, 10);
	printf("%s\n", s);

	free(s);
	tt_int_free(ti);
	tt_int_free(two);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x93a4(%rip), %rdi      # 0xb034
movl %ebp, %esi
xorl %eax, %eax
callq 0x10c0
cmpl $0x1, %ebp
jne 0x1cb4
leaq 0x9422(%rip), %rdi      # 0xb0c7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1060
callq 0x4910
movq %rax, %rbx
callq 0x4910
movq %rax, %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5804
movl $0x2, %esi
movq %r14, %rdi
callq 0x5804
decl %ebp
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6e1a
movq %rbx, %rdi
callq 0x8bbe
testb %al, %al
je 0x1ce0
decl %ebp
jne 0x1ce0
movq %rsp, %r15
movq $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x5127
movq (%r15), %rdi
callq 0x1060
movq (%r15), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x4970
movq %r14, %rdi
callq 0x4970
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cyb70289[P]tt/tests/number.c
// Function: test_mersenne
void test_mersenne(void)
{
	/* Mersenne number: 2^N - 1 */
	#define N	521
	const int n = N + 1;
	int sz = (n + _tt_word_bits - 1) / _tt_word_bits;
	_tt_word m[sz+1];
	m[sz] = 0;
	for (int i = 0; i < sz-1; i++)
		m[i] = ~_tt_word_top_bit;
	m[sz-1] = (1 << (n - _tt_word_bits*(sz-1) - 1)) - 1;
	if (m[sz-1] == 0)
		sz--;
	struct tt_int ti = _TT_INT_DECL(sz, m);

	if (tt_int_isprime(&ti))
		printf("Prime: ");
	else
		printf("Composite: ");
	printf("2^%d - 1\n", N);
}

// Assembly:
subq $0x78, %rsp
movq $0x0, 0x68(%rsp)
xorl %eax, %eax
movaps 0x92b7(%rip), %xmm0     # 0xb010
movaps %xmm0, 0x20(%rsp,%rax,8)
addq $0x2, %rax
cmpq $0x8, %rax
jne 0x1d59
leaq 0x20(%rsp), %rax
movq $0x1ffff, 0x40(%rax)    # imm = 0x1FFFF
movabsq $0x900000000, %rcx      # imm = 0x900000000
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
movl $0x9, 0x8(%rdi)
movq %rax, 0x10(%rdi)
callq 0x8bbe
leaq 0x9282(%rip), %rcx      # 0xb020
leaq 0x9283(%rip), %rdi      # 0xb028
testb %al, %al
cmovneq %rcx, %rdi
xorl %eax, %eax
callq 0x10c0
leaq 0x9289(%rip), %rdi      # 0xb042
movl $0x209, %esi            # imm = 0x209
xorl %eax, %eax
callq 0x10c0
addq $0x78, %rsp
retq