LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x44bf1
movq (%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x44af8
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x44b10
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x44b28
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x44b40
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x44b58
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x44b70
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x44b88
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x44ba0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x44bb8
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x44bd0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x44be8
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/mser.c
// Function: climb
VL_INLINE vl_uint
climb (VlMserReg* r, vl_uint idx)
{

  vl_uint prev_idx = idx ;
  vl_uint next_idx ;
  vl_uint root_idx ;

  /* move towards root to find it */
  while (1) {

    /* next jump to the root */
    next_idx = r [idx] .shortcut ;

    /* recycle shortcut to remember how we came here */
    r [idx] .shortcut = prev_idx ;

    /* stop if the root is found */
    if( next_idx == idx ) break ;

    /* next guy */
    prev_idx = idx ;
    idx      = next_idx ;
  }

  root_idx = idx ;

  /* move backward to update shortcuts */
  while (1) {

    /* get previously visited one */
    prev_idx = r [idx] .shortcut ;

    /* update shortcut to point to the new root */
    r [idx] .shortcut = root_idx ;

    /* stop if the first visited node is reached */
    if( prev_idx == idx ) break ;

    /* next guy */
    idx = prev_idx ;
  }

  return root_idx ;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rsp)
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rsp), %eax
cmpl -0xc(%rsp), %eax
jne 0x4607b
jmp 0x4608d
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0x46041
movl -0xc(%rsp), %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rsp)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jne 0x460cf
jmp 0x460d9
movl -0x10(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0x46095
movl -0x18(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/mser.c
// Function: adv
VL_INLINE void
adv(int ndims, int const *dims, int *subs)
{
  int d = 0 ;
  while(d < ndims) {
    if( ++subs[d]  < dims[d] ) return ;
    subs[d++] = 0 ;
  }
}

// Assembly:
movl %edi, -0x4(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0x4(%rsp), %eax
jge 0x466a2
movq -0x18(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
movl (%rcx,%rdx,4), %eax
addl $0x1, %eax
movl %eax, (%rcx,%rdx,4)
movq -0x10(%rsp), %rcx
movslq -0x1c(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x46684
jmp 0x466a2
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rsp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x46656
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x94b0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $-0x1, %eax
je 0x46a21
jmp 0x469ce
movl 0x4(%rsp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x469fd
jmp 0x469dc
movl 0x4(%rsp), %eax
subl $0xd, %eax
je 0x469fd
jmp 0x469e7
movl 0x4(%rsp), %eax
subl $0x20, %eax
je 0x469fd
jmp 0x469f2
movl 0x4(%rsp), %eax
subl $0x23, %eax
je 0x46a0a
jmp 0x46a23
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x46a33
movq 0x10(%rsp), %rdi
callq 0x472e0
addl $0x1, %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x46a33
jmp 0x46a38
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x97c0
jmp 0x46a38
jmp 0x469b1
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x132aa(%rip), %rsi     # 0x5a0a1
callq 0x9960
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x46e2a
movq 0x28(%rsp), %rdx
movl $0x68, %edi
leaq 0x1328a(%rip), %rsi     # 0x5a0a4
movb $0x0, %al
callq 0x9160
movl %eax, 0x34(%rsp)
jmp 0x46eed
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9440
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x46e5b
movq 0x8(%rsp), %rdi
callq 0x92e0
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x46eed
movq 0x20(%rsp), %rdi
callq 0x9770
cmpq $0x1, %rax
jbe 0x46e84
movl $0x3, %edi
leaq 0x13255(%rip), %rsi     # 0x5a0cc
movb $0x0, %al
callq 0x9160
movl %eax, 0x34(%rsp)
jmp 0x46eed
movq 0x20(%rsp), %rdi
callq 0x9760
movq %rax, %rdi
shlq $0x0, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
callq 0x97f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x46edb
movq 0x18(%rsp), %rdi
callq 0x9620
movq 0x8(%rsp), %rdi
callq 0x92e0
movq 0x8(%rsp), %rdi
callq 0x92e0
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x9110
movl %eax, 0x34(%rsp)
cmpl $0x0, 0x34(%rsp)
je 0x46f47
movl 0x34(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x4702e
movq 0x40(%rsp), %rdi
callq 0x9760
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
shlq $0x2, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xc(%rsp)
testq %rax, %rax
movss %xmm0, 0x10(%rsp)
js 0x46fb1
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movss 0x10(%rsp), %xmm1
movss 0x121d1(%rip), %xmm0    # 0x59190
divss %xmm1, %xmm0
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x4701c
movss 0x14(%rsp), %xmm0
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movss %xmm0, (%rax,%rcx,4)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x46fd2
movq 0x20(%rsp), %rdi
callq 0x9620
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x13081(%rip), %rsi     # 0x5a0eb
callq 0x9960
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4709a
movq 0x48(%rsp), %rdx
movl $0x68, %edi
leaq 0x13061(%rip), %rsi     # 0x5a0ee
movb $0x0, %al
callq 0x9160
movl %eax, 0x54(%rsp)
jmp 0x470e9
movslq 0x3c(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x1, 0x28(%rsp)
movq $0xff, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rsi
callq 0x90f0
movl %eax, 0x34(%rsp)
movq 0x8(%rsp), %rdi
callq 0x92e0
movl 0x34(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movss 0x12ff2(%rip), %xmm0    # 0x5a118
movss %xmm0, 0x24(%rsp)
movss 0x12fe4(%rip), %xmm0    # 0x5a118
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, 0x20(%rsp)
movslq 0x34(%rsp), %rdi
shlq $0x2, %rdi
movslq 0x30(%rsp), %rax
imulq %rax, %rdi
callq 0x9660
movq %rax, 0x10(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl 0x34(%rsp), %ecx
imull 0x30(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4721e
movss 0x24(%rsp), %xmm1
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x471a8
movss 0x24(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x471bd
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0xc(%rsp)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x24(%rsp)
movss 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
ucomiss (%rax,%rcx,4), %xmm0
jbe 0x471ed
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
jmp 0x47202
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x20(%rsp)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x4716b
movss 0x20(%rsp), %xmm1
subss 0x24(%rsp), %xmm1
movss 0x11fc6(%rip), %xmm0    # 0x591f8
addss %xmm0, %xmm1
movss 0x12df2(%rip), %xmm0    # 0x5a030
divss %xmm1, %xmm0
movss %xmm0, 0x1c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl 0x34(%rsp), %ecx
imull 0x30(%rsp), %ecx
cmpl %ecx, %eax
jge 0x472a4
movq 0x38(%rsp), %rax
movslq 0x28(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x24(%rsp), %xmm1
subss %xmm1, %xmm0
movss 0x1c(%rsp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movslq 0x28(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x47250
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x34(%rsp), %edx
movl 0x30(%rsp), %ecx
callq 0x9420
movl %eax, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9620
movl 0x2c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/pgm.c
// Function: remove_line
static int
remove_line(FILE* f)
{
  int count = 0 ;
  int c ;

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

    switch(c) {
    case '\n' :
      goto quit_remove_line ;

    case EOF :
      -- count ;
      goto quit_remove_line ;
    }
  }
 quit_remove_line :
  return count ;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x94b0
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
incl %eax
movl %eax, 0xc(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $-0x1, %eax
je 0x47325
jmp 0x47318
movl 0x4(%rsp), %eax
subl $0xa, %eax
jne 0x47332
jmp 0x47323
jmp 0x47334
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x47334
jmp 0x472f1
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl $0x40, %edi
callq 0x9660
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl 0x2c(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x28(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0x14(%rax)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jle 0x473b5
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x473bd
movl 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x32, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm1
movsd 0x11cdf(%rip), %xmm0    # 0x590c8
divsd %xmm0, %xmm1
movsd 0x11ceb(%rip), %xmm0    # 0x590e0
ucomisd %xmm1, %xmm0
jbe 0x4740b
movsd 0x11cdd(%rip), %xmm0    # 0x590e0
movsd %xmm0, 0x8(%rsp)
jmp 0x47427
movq 0x18(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd 0x11cab(%rip), %xmm1    # 0x590c8
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movl 0x2c(%rsp), %eax
imull 0x28(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x9a70
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rax)
movl 0x2c(%rsp), %eax
imull 0x28(%rsp), %eax
movslq %eax, %rdi
movl $0x4, %esi
callq 0x9a70
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rax)
movl 0x2c(%rsp), %eax
imull 0x28(%rsp), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x9a70
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_inner
VL_INLINE
vl_qs_type
vl_quickshift_inner(vl_qs_type const * I,
      int N1, int N2, int K,
      int i1, int i2,
      int j1, int j2)
{
  vl_qs_type ker = 0 ;
  int k ;
  ker += i1*j1 + i2*j2 ;
  for (k = 0 ; k < K ; ++k) {
    ker +=
      I [i1 + N1 * i2 + (N1*N2) * k] *
      I [j1 + N1 * j2 + (N1*N2) * k] ;
  }
  return ker ;
}

// Assembly:
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x18(%rsp), %eax
imull 0x8(%rsp), %eax
movl -0x1c(%rsp), %ecx
imull 0x10(%rsp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
addsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movl $0x0, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x4858e
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl -0xc(%rsp), %edx
imull -0x1c(%rsp), %edx
addl %edx, %ecx
movl -0xc(%rsp), %edx
imull -0x10(%rsp), %edx
imull -0x2c(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movl 0x8(%rsp), %ecx
movl -0xc(%rsp), %edx
imull 0x10(%rsp), %edx
addl %edx, %ecx
movl -0xc(%rsp), %edx
imull -0x10(%rsp), %edx
imull -0x2c(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x48508
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_distance
VL_INLINE
vl_qs_type
vl_quickshift_distance(vl_qs_type const * I,
         int N1, int N2, int K,
         int i1, int i2,
         int j1, int j2)
{
  vl_qs_type dist = 0 ;
  int d1 = j1 - i1 ;
  int d2 = j2 - i2 ;
  int k ;
  dist += d1*d1 + d2*d2 ;
  /* For k = 0...K-1, d+= L2 distance between I(i1,i2,k) and
   * I(j1,j2,k) */
  for (k = 0 ; k < K ; ++k) {
    vl_qs_type d =
      I [i1 + N1 * i2 + (N1*N2) * k] -
      I [j1 + N1 * j2 + (N1*N2) * k] ;
    dist += d*d ;
  }
  return dist ;
}

// Assembly:
movl 0x10(%rsp), %eax
movl 0x8(%rsp), %eax
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl %ecx, -0x14(%rsp)
movl %r8d, -0x18(%rsp)
movl %r9d, -0x1c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rsp)
movl 0x8(%rsp), %eax
subl -0x18(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl 0x10(%rsp), %eax
subl -0x1c(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x2c(%rsp), %eax
imull -0x2c(%rsp), %eax
movl -0x30(%rsp), %ecx
imull -0x30(%rsp), %ecx
addl %ecx, %eax
cvtsi2sd %eax, %xmm0
addsd -0x28(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
cmpl -0x14(%rsp), %eax
jge 0x486ac
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl -0xc(%rsp), %edx
imull -0x1c(%rsp), %edx
addl %edx, %ecx
movl -0xc(%rsp), %edx
imull -0x10(%rsp), %edx
imull -0x34(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rsp), %rax
movl 0x8(%rsp), %ecx
movl -0xc(%rsp), %edx
imull 0x10(%rsp), %edx
addl %edx, %ecx
movl -0xc(%rsp), %edx
imull -0x10(%rsp), %edx
imull -0x34(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
subsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rsp)
movsd -0x40(%rsp), %xmm0
movsd -0x40(%rsp), %xmm2
movsd -0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rsp)
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x48610
movsd -0x28(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4871d
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x486e4
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x486fc
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x48714
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %ecx
andl $-0x1, %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
movl $0x1, 0x9c0(%rax)
movq -0x8(%rsp), %rax
cmpl $0x270, 0x9c0(%rax)     # imm = 0x270
jae 0x48816
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x9c0(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movq -0x8(%rsp), %rcx
movq -0x8(%rsp), %rdx
movl 0x9c0(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
movl (%rcx,%rdx,4), %ecx
shrl $0x1e, %ecx
xorl %ecx, %eax
imull $0x6c078965, %eax, %edx # imm = 0x6C078965
movq -0x8(%rsp), %rax
addl 0x9c0(%rax), %edx
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x9c0(%rcx), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x9c0(%rcx), %ecx
movl (%rax,%rcx,4), %edx
andl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
movl 0x9c0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x9c0(%rax)
jmp 0x48776
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jle 0x48ab5
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
callq 0x48ac0
cltq
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x48a41
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rdi)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x4aa4c
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4aa56
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %xmm0
movaps 0xe6f9(%rip), %xmm1     # 0x59160
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xe6fd(%rip), %xmm1     # 0x59170
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x4abc0
callq 0x9a00
movsd 0xe634(%rip), %xmm1     # 0x590c8
subsd %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4ab0c
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x4aab9
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x4aac3
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %xmm0
movaps 0xe68c(%rip), %xmm1     # 0x59160
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xe690(%rip), %xmm1     # 0x59170
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x4abc0
callq 0x9a00
movsd 0xe5c7(%rip), %xmm1     # 0x590c8
subsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
jmp 0x4ab16
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
jmp 0x4ab16
movq 0x18(%rsp), %rax
movsd (%rsp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x18(%rax)
movq $0x3, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq 0x20(%rax), %rcx
decq %rcx
movq %rcx, 0x30(%rax)
movq 0x20(%rax), %xmm0
movaps 0xe610(%rip), %xmm1     # 0x59160
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xe614(%rip), %xmm1     # 0x59170
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0xe565(%rip), %xmm1     # 0x590d8
divsd %xmm0, %xmm1
movsd 0xe561(%rip), %xmm0     # 0x590e0
callq 0x92b0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0xf59f(%rip), %xmm0     # 0x5a138
mulsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rcx)
movsd 0xe4d6(%rip), %xmm0     # 0x59080
movsd %xmm0, 0x40(%rcx)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
leaq 0x50(%rsp), %rdx
movq %rdx, -0x18(%rsp)
leaq 0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x1(%rsp)
jne 0x4acce
movq -0x18(%rsp), %rdx
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x1(%rsp)
jne 0x4acce
movq -0x18(%rsp), %rdx
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x1(%rsp)
jne 0x4acce
movq -0x18(%rsp), %rdx
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x1(%rsp)
jne 0x4acce
movq -0x18(%rsp), %rdx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rcx
xorl %eax, %eax
cmpq 0x20(%rdx), %rcx
movb %al, -0x1(%rsp)
jne 0x4acce
movq -0x18(%rsp), %rdx
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
xorl %eax, %eax
cmpq 0x30(%rdx), %rcx
movb %al, -0x1(%rsp)
jne 0x4acce
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movsd 0x38(%rax), %xmm0
xorl %eax, %eax
ucomisd 0x38(%rcx), %xmm0
movb %al, -0x1(%rsp)
jne 0x4acce
jp 0x4acce
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movsd 0x40(%rcx), %xmm0
ucomisd 0x40(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
xorl %eax, %eax
subq 0x28(%rsp), %rax
cmpq $0x0, %rax
jl 0x4ad4e
movq 0x30(%rsp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
subq 0x28(%rsp), %rcx
shlq %cl, %rax
movq %rax, 0x10(%rsp)
jmp 0x4ad6c
movq 0x30(%rsp), %rax
movq (%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
subq 0x28(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shrq %cl, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
xorl %eax, %eax
subq 0x28(%rsp), %rax
cmpq $0x0, %rax
jl 0x4ada0
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
subq 0x28(%rsp), %rcx
shlq %cl, %rax
movq %rax, 0x8(%rsp)
jmp 0x4adbf
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
subq 0x28(%rsp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shrq %cl, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
cvtsi2sdq 0x28(%rsp), %xmm1
movsd 0xe304(%rip), %xmm0     # 0x590e0
callq 0x92b0
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movsd %xmm0, 0x10(%rcx)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x9230
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x4b1fe
movq $0x0, 0x40(%rsp)
jmp 0x4b2bc
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jg 0x4b2b2
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x96c0
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rsp), %rcx
subq 0x28(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdx
subq 0x10(%rdx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x38(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdx
subq 0x10(%rdx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rdx
imulq 0x18(%rsp), %rdx
imulq 0x8(%rsp), %rdx
shlq $0x2, %rdx
callq 0x9640
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x4b20c
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4b3c7
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4b3bd
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jg 0x4b3af
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq 0x10(%rdx), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x4b39d
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq 0x10(%rdx), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9620
jmp 0x4b39f
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4b34f
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq 0x10(%rsp), %rdi
callq 0x9620
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rdi
callq 0x96c0
movq 0x50(%rsp), %rax
movq 0x28(%rax), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jg 0x4b51c
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x9950
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
subq $0x1, %rdx
callq 0x9950
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x96a0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x9040
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
subq $0x1, %rdx
callq 0x9040
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq (%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movsd 0x10(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd 0x38(%rsp), %xmm1
callq 0x98e0
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x4b404
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/scalespace.c
// Function: vl_scalespace_put_image
void
vl_scalespace_put_image (VlScaleSpace *self, float const *image)
{
  vl_index o ;
  _vl_scalespace_start_octave_from_image(self, image, self->geom.firstOctave) ;
  _vl_scalespace_fill_octave(self, self->geom.firstOctave) ;
  for (o = self->geom.firstOctave + 1 ; o <= self->geom.lastOctave ; ++o) {
    _vl_scalespace_start_octave_from_previous_octave(self, o) ;
    _vl_scalespace_fill_octave(self, o) ;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x4b5c0
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x4b3d0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jg 0x4b5b3
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4b8b0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4b3d0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4b57a
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/scalespace.c
// Function: copy_and_downsample
static void
copy_and_downsample
(float *destination,
 float const *source,
 vl_size width, vl_size height, vl_size numOctaves)
{
  vl_index x, y ;
  vl_size step = 1 << numOctaves ; /* step = 2^numOctaves */

  assert(destination) ;
  assert(source) ;

  if (numOctaves == 0) {
    memcpy(destination, source, sizeof(float) * width * height) ;
  } else {
    for(y = 0 ; y < (signed)height ; y += step) {
      float const *p = source + y * width ;
      for(x = 0 ; x < (signed)width - ((signed)step - 1) ; x += step) {
        *destination++ = *p ;
        p += step ;
      }
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
cltq
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4bb6d
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
shlq $0x2, %rdx
imulq 0x28(%rsp), %rdx
callq 0x9640
jmp 0x4bc23
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x4bc21
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rcx
imulq 0x30(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rdx
subl $0x1, %edx
subl %edx, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x4bc0b
movq (%rsp), %rax
movss (%rax), %xmm0
movq 0x40(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x40(%rsp)
movss %xmm0, (%rax)
movq 0x8(%rsp), %rax
shlq $0x2, %rax
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x4bbb0
jmp 0x4bc0d
movq 0x8(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4bb76
jmp 0x4bc23
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/scalespace.c
// Function: copy_and_upsample
static void
copy_and_upsample
(float *destination,
 float const *source, vl_size width, vl_size height)
{
  vl_index x, y, ox, oy ;
  float v00, v10, v01, v11 ;

  assert(destination) ;
  assert(source) ;

  for(y = 0 ; y < (signed)height ; ++y) {
    oy = (y < ((signed)height - 1)) * width ;
    v10 = source[0] ;
    v11 = source[oy] ;
    for(x = 0 ; x < (signed)width ; ++x) {
      ox = x < ((signed)width - 1) ;
      v00 = v10 ;
      v01 = v11 ;
      v10 = source[ox] ;
      v11 = source[ox + oy] ;
      destination[0] = v00 ;
      destination[1] = 0.5f * (v00 + v10) ;
      destination[2*width] = 0.5f * (v00 + v01) ;
      destination[2*width+1] = 0.25f * (v00 + v01 + v10 + v11) ;
      destination += 2 ;
      source ++;
    }
    destination += 2*width ;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq -0x20(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x4be21
movq -0x30(%rsp), %rax
movq -0x20(%rsp), %rcx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
imulq -0x18(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x10(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x48(%rsp)
movq -0x10(%rsp), %rax
movq -0x40(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x50(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x4bdf8
movq -0x28(%rsp), %rax
movq -0x18(%rsp), %rcx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x38(%rsp)
movss -0x48(%rsp), %xmm0
movss %xmm0, -0x44(%rsp)
movss -0x50(%rsp), %xmm0
movss %xmm0, -0x4c(%rsp)
movq -0x10(%rsp), %rax
movq -0x38(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x48(%rsp)
movq -0x10(%rsp), %rax
movq -0x38(%rsp), %rcx
addq -0x40(%rsp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x50(%rsp)
movss -0x44(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movss -0x44(%rsp), %xmm1
addss -0x48(%rsp), %xmm1
movss 0xd496(%rip), %xmm0     # 0x591f0
mulss %xmm1, %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, 0x4(%rax)
movss -0x44(%rsp), %xmm1
addss -0x4c(%rsp), %xmm1
movss 0xd474(%rip), %xmm0     # 0x591f0
mulss %xmm1, %xmm0
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
shlq %rcx
movss %xmm0, (%rax,%rcx,4)
movss -0x44(%rsp), %xmm1
addss -0x4c(%rsp), %xmm1
addss -0x48(%rsp), %xmm1
addss -0x50(%rsp), %xmm1
movss 0xe38e(%rip), %xmm0     # 0x5a140
mulss %xmm1, %xmm0
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
shlq %rcx
movss %xmm0, 0x4(%rax,%rcx,4)
movq -0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x4bcb8
movq -0x18(%rsp), %rax
shlq %rax
shlq $0x2, %rax
addq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rsp)
jmp 0x4bc4d
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4c31f
movq (%rsp), %rax
cmpq $0x0, 0x78(%rax)
je 0x4c298
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x4c2b6
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x4c2ce
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4c2e6
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4c2fe
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x4c316
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x4ca47
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rsp)
movss (%rax), %xmm0
movss %xmm0, -0x24(%rsp)
movss %xmm0, -0x28(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4c9c3
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x10(%rsp)
movss (%rax), %xmm0
movss %xmm0, -0x28(%rsp)
movss -0x24(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movss -0x24(%rsp), %xmm0
addss -0x28(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0xc702(%rip), %xmm0     # 0x59080
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movss -0x28(%rsp), %xmm0
movss %xmm0, -0x24(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x4c911
movss -0x28(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movss -0x28(%rsp), %xmm0
movq -0x8(%rsp), %rax
movss %xmm0, (%rax)
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl -0x14(%rsp), %eax
shll %eax
imull -0x18(%rsp), %eax
movl $0x1, %ecx
subl %eax, %ecx
movq -0x8(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rsp)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x4c8da
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/sift.c
// Function: copy_and_downsample
static void
copy_and_downsample
(vl_sift_pix       *dst,
 vl_sift_pix const *src,
 int width, int height, int d)
{
  int x, y ;

  d = 1 << d ; /* d = 2^d */
  for(y = 0 ; y < height ; y+=d) {
    vl_sift_pix const * srcrowp = src + y * width ;
    for(x = 0 ; x < width - (d-1) ; x+=d) {
      *dst++ = *srcrowp ;
      srcrowp += d ;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x18(%rsp), %eax
jge 0x4cb1d
movq -0x10(%rsp), %rax
movl -0x24(%rsp), %ecx
imull -0x14(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl $0x0, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x14(%rsp), %ecx
movl -0x1c(%rsp), %edx
subl $0x1, %edx
subl %edx, %ecx
cmpl %ecx, %eax
jge 0x4cb0a
movq -0x30(%rsp), %rax
movss (%rax), %xmm0
movq -0x8(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x8(%rsp)
movss %xmm0, (%rax)
movl -0x1c(%rsp), %ecx
movq -0x30(%rsp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movl -0x1c(%rsp), %eax
addl -0x20(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0x4cab1
jmp 0x4cb0c
movl -0x1c(%rsp), %eax
addl -0x24(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0x4ca7e
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/sift.c
// Function: fast_expn
VL_INLINE double
fast_expn (double x)
{
  double a,b,r ;
  int i ;
  /*assert(0 <= x && x <= EXPN_MAX) ;*/

  if (x > EXPN_MAX) return 0.0 ;

  x *= EXPN_SZ / EXPN_MAX ;
  i = (int)vl_floor_d (x) ;
  r = x - i ;
  a = expn_tab [i    ] ;
  b = expn_tab [i + 1] ;
  return a + r * (b - a) ;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
movsd 0x99c0(%rip), %xmm1     # 0x5a168
ucomisd %xmm1, %xmm0
jbe 0x507bc
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x5084e
movsd 0x99ac(%rip), %xmm0     # 0x5a170
mulsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x50860
movl %eax, 0xc(%rsp)
movsd 0x28(%rsp), %xmm0
cvtsi2sdl 0xc(%rsp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x10fff(%rip), %rax     # 0x61800
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x10fe3(%rip), %rax     # 0x61800
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
subsd 0x20(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)