LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_extract_data
VL_EXPORT
int
vl_pgm_extract_data (FILE* f, VlPgmImage const *im, void *data)
{
  vl_size bpp = vl_pgm_get_bpp(im) ;
  vl_size data_size = vl_pgm_get_npixels(im) ;
  vl_bool good = 1 ;
  size_t c ;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %rbp
imulq (%rsi), %r14
cmpl $0x0, 0x18(%rsi)
je 0x23d23
cmpq $0x100, %rbp            # imm = 0x100
pushq $0x2
popq %rsi
sbbq $0x0, %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x91c0
xorl %ecx, %ecx
cmpq %r14, %rax
sete %cl
cmpq $0x100, %rbp            # imm = 0x100
jae 0x23d70
xorl %eax, %eax
testl %ecx, %ecx
jne 0x23d14
leaq 0xa4e2(%rip), %rsi      # 0x2e1ec
pushq $0x67
popq %rdi
xorl %eax, %eax
callq 0x9150
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rcx
leaq 0x4(%rsp), %r13
xorl %r12d, %r12d
cmpq %r14, %r12
jae 0x23cfd
testl %ecx, %ecx
je 0x23cfd
movq %r15, %rdi
leaq 0xa4a6(%rip), %rsi      # 0x2e1e7
movq %r13, %rdx
xorl %eax, %eax
callq 0x9120
movl 0x4(%rsp), %ecx
cmpq $0xff, %rbp
ja 0x23d5e
movb %cl, (%rbx,%r12)
jmp 0x23d63
movw %cx, (%rbx,%r12,2)
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
incq %r12
jmp 0x23d2e
addq %r14, %r14
xorl %eax, %eax
cmpq %r14, %rax
jae 0x23cfd
rolw $0x8, (%rbx,%rax)
addq $0x2, %rax
jmp 0x23d75
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_read_new
VL_EXPORT
int vl_pgm_read_new (char const *name, VlPgmImage *im, vl_uint8** data)
{
  int err = 0 ;
  FILE *f = fopen (name, "rb") ;

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

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

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

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

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

  fclose (f) ;
  return err ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0xa3bc(%rip), %rsi      # 0x2e221
callq 0x9850
testq %rax, %rax
je 0x23e96
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x93e0
testl %eax, %eax
je 0x23eb2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x92b0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa387(%rip), %rsi      # 0x2e224
pushq $0x68
popq %rdi
movq %r12, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9150
cmpq $0x100, 0x10(%r15)      # imm = 0x100
jb 0x23ed5
leaq 0xa389(%rip), %rsi      # 0x2e24c
pushq $0x3
popq %rdi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9150
movq 0x8(%r15), %rdi
imulq (%r15), %rdi
callq 0x95e0
movq %rax, (%r14)
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9710
movl %eax, %ebp
testl %eax, %eax
je 0x23e83
movq %r14, %rdi
callq 0x95b0
movq %rbx, %rdi
callq 0x92b0
jmp 0x23e83
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/pgm.c
// Function: vl_pgm_read_new_f
VL_EXPORT
int vl_pgm_read_new_f (char const *name,  VlPgmImage *im, float** data)
{
  int err = 0 ;
  size_t npixels ;
  vl_uint8 *idata ;

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

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

  vl_free (idata) ;
  return 0 ;
}

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

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

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

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

  return err ;
}

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

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

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

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

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

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

  vl_free (buffer) ;
  return err ;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movslq %edx, %rax
movslq %ecx, %rdi
imulq %rax, %rdi
shlq $0x2, %rdi
callq 0x95e0
movq %rax, %r12
movl %ebx, %eax
imull %ebp, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movss 0x945f(%rip), %xmm1     # 0x2d4d0
movss 0x91f7(%rip), %xmm0     # 0x2d270
cmpq %rcx, %rax
je 0x24091
movss (%r15,%rcx,4), %xmm2
minss %xmm2, %xmm0
maxss %xmm2, %xmm1
incq %rcx
jmp 0x24079
subss %xmm0, %xmm1
addss 0x928f(%rip), %xmm1     # 0x2d32c
movss 0xa10b(%rip), %xmm2     # 0x2e1b0
divss %xmm1, %xmm2
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x240cb
movss (%r15,%rcx,4), %xmm1
subss %xmm0, %xmm1
mulss %xmm2, %xmm1
cvttss2si %xmm1, %edx
movb %dl, (%r12,%rcx)
incq %rcx
jmp 0x240ab
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movl %ebx, %ecx
callq 0x93c0
movl %eax, %ebx
movq %r12, %rdi
callq 0x95b0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_new
VL_EXPORT
VlQS *
vl_quickshift_new(vl_qs_type const * image, int height, int width,
                       int channels)
{
  VlQS * q = vl_malloc(sizeof(VlQS));

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

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

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

  return q;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r12
pushq $0x40
popq %rdi
callq 0x95e0
movq %rax, %rbx
movq %r12, (%rax)
movl %r14d, 0x8(%rax)
movl %ebp, 0xc(%rax)
movl %r15d, 0x10(%rax)
andl $0x0, 0x14(%rax)
cmpl %ebp, %r14d
movl %ebp, %eax
cmovgl %r14d, %eax
pushq $0x32
popq %rcx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x20(%rbx)
divsd 0x90a8(%rip), %xmm0     # 0x2d1e8
movsd 0x98f0(%rip), %xmm1     # 0x2da38
maxsd %xmm0, %xmm1
movsd %xmm1, 0x18(%rbx)
imull %r14d, %ebp
movslq %ebp, %r14
pushq $0x8
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x9960
movq %rax, 0x30(%rbx)
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x9960
movq %rax, 0x28(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9960
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movl 0x18(%rsp), %r10d
movl 0x10(%rsp), %eax
movl %eax, %r11d
subl %r8d, %r11d
movl %r10d, %ebx
subl %r9d, %ebx
imull %r11d, %r11d
imull %ebx, %ebx
addl %r11d, %ebx
cvtsi2sd %ebx, %xmm0
imull %esi, %r10d
addl %eax, %r10d
imull %esi, %r9d
addl %r8d, %r9d
imull %esi, %edx
movslq %edx, %rax
movslq %r9d, %rdx
movslq %r10d, %rsi
xorl %r8d, %r8d
testl %ecx, %ecx
cmovgl %ecx, %r8d
shlq $0x3, %rax
subq $0x1, %r8
jb 0x24bd3
movsd (%rdi,%rdx,8), %xmm1
subsd (%rdi,%rsi,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
addq %rax, %rdi
jmp 0x24bb6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/quickshift.c
// Function: vl_quickshift_delete
void vl_quickshift_delete(VlQS * q)
{
  if (q) {
    if (q->parents) vl_free(q->parents);
    if (q->dists)   vl_free(q->dists);
    if (q->density) vl_free(q->density);

    vl_free(q);
  }
}

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

// Assembly:
movl %esi, (%rdi)
pushq $0x1
popq %rax
movl %eax, 0x9c0(%rdi)
cmpl $0x26f, %eax            # imm = 0x26F
ja 0x24c66
leal -0x1(%rax), %ecx
movl (%rdi,%rcx,4), %ecx
movl %ecx, %edx
shrl $0x1e, %edx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
movl %eax, %eax
movl %ecx, (%rdi,%rax,4)
movl 0x9c0(%rdi), %eax
incl %eax
jmp 0x24c35
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x12bd6aa, %esi        # imm = 0x12BD6AA
callq 0x9480
cmpq $0x271, %r14            # imm = 0x271
movl $0x270, %ecx            # imm = 0x270
cmovaeq %r14, %rcx
xorl %edx, %edx
pushq $0x1
popq %rsi
movl %esi, %eax
xorl %edi, %edi
subl $0x1, %ecx
jb 0x24cea
movslq %eax, %r8
movl -0x4(%rbx,%r8,4), %r9d
movl %r9d, %r10d
shrl $0x1e, %r10d
xorl %r9d, %r10d
imull $0x19660d, %r10d, %r9d  # imm = 0x19660D
xorl (%rbx,%r8,4), %r9d
movslq %edi, %r10
movl (%r15,%r10,4), %r11d
addl %r10d, %r11d
addl %r9d, %r11d
movl %r11d, (%rbx,%r8,4)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x24cd6
incl %eax
jmp 0x24ce0
movl 0x9bc(%rbx), %eax
movl %eax, (%rbx)
movl %esi, %eax
incl %edi
cmpl %r14d, %edi
cmovgel %edx, %edi
jmp 0x24c98
movl $0xfffffd91, %ecx       # imm = 0xFFFFFD91
pushq $0x1
popq %rdx
testl %ecx, %ecx
je 0x24d2f
movslq %eax, %rsi
movl -0x4(%rbx,%rsi,4), %edi
movl %edi, %r8d
shrl $0x1e, %r8d
xorl %edi, %r8d
imull $0x5d588b65, %r8d, %edi # imm = 0x5D588B65
xorl (%rbx,%rsi,4), %edi
subl %esi, %edi
movl %edi, (%rbx,%rsi,4)
cmpl $0x26f, %eax            # imm = 0x26F
jge 0x24d21
incl %eax
jmp 0x24d2b
movl 0x9bc(%rbx), %eax
movl %eax, (%rbx)
movl %edx, %eax
incl %ecx
jmp 0x24cf2
movl $0x80000000, (%rbx)     # imm = 0x80000000
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x1(%r15), %r13
testq %r13, %r13
jle 0x24daa
movq %r15, %rbp
shrq $0x20, %rbp
movq %r14, %rdi
callq 0x9360
movl %eax, %r12d
testq %rbp, %rbp
jne 0x24d79
movl %r12d, %eax
xorl %edx, %edx
divl %r15d
jmp 0x24d92
movq %r14, %rdi
callq 0x9360
movl %eax, %eax
shlq $0x20, %r12
orq %rax, %r12
movq %r12, %rax
xorl %edx, %edx
divq %r15
movq (%rbx,%r13,8), %rax
movslq %edx, %rcx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%rbx,%r13,8)
movq %rax, (%rbx,%rcx,8)
movq %r13, %r15
jmp 0x24d4f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/random.c
// Function: vl_rand_uint32
vl_uint32
vl_rand_uint32 (VlRand * self)
{
  vl_uint32 y;
  static vl_uint32 mag01[2]={VL_UINT32_C(0x0), MATRIX_A};
  /* mag01[x] = x * MATRIX_A  for x=0,1 */

#define mti self->mti
#define mt self->mt

  if (mti >= N) { /* generate N words at one time */
    int kk;

    if (mti == N+1)   /* if init_genrand() has not been called, */
      vl_rand_seed (self, VL_UINT32_C(5489)); /* a default initial seed is used */

    for (kk=0;kk<N-M;kk++) {
      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
      mt[kk] = mt[kk+M] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
    }
    for (;kk<N-1;kk++) {
      y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
      mt[kk] = mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];
    }
    y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
    mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[y & VL_UINT32_C(0x1)];

    mti = 0;
  }

  y = mt[mti++];

  /* Tempering */
  y ^= (y >> 11);
  y ^= (y << 7) & VL_UINT32_C(0x9d2c5680);
  y ^= (y << 15) & VL_UINT32_C(0xefc60000);
  y ^= (y >> 18);

  return (vl_uint32)y;

#undef mti
#undef mt
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x9c0(%rdi), %eax
cmpl $0x270, %eax            # imm = 0x270
jb 0x24e9e
cmpl $0x271, %eax            # imm = 0x271
jne 0x24de2
movq %rbx, %rdi
movl $0x1571, %esi           # imm = 0x1571
callq 0x9480
xorl %ecx, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
leaq 0x94b0(%rip), %rax      # 0x2e2a0
cmpq $0xe3, %rcx
je 0x24e2a
movl (%rbx,%rcx,4), %esi
andl %edx, %esi
movl 0x4(%rbx,%rcx,4), %edi
movl %edi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %esi, %r8d
shrl %r8d
andl $0x1, %edi
movl (%rax,%rdi,4), %esi
xorl 0x634(%rbx,%rcx,4), %esi
xorl %r8d, %esi
movl %esi, (%rbx,%rcx,4)
incq %rcx
jmp 0x24df0
movl $0xe4, %ecx
movl $0x80000000, %edx       # imm = 0x80000000
cmpq $0x270, %rcx            # imm = 0x270
je 0x24e6f
movl -0x4(%rbx,%rcx,4), %esi
andl %edx, %esi
movl (%rbx,%rcx,4), %edi
movl %edi, %r8d
andl $0x7ffffffe, %r8d       # imm = 0x7FFFFFFE
orl %esi, %r8d
andl $0x1, %edi
movl (%rax,%rdi,4), %esi
xorl -0x390(%rbx,%rcx,4), %esi
shrl %r8d
xorl %r8d, %esi
movl %esi, -0x4(%rbx,%rcx,4)
incq %rcx
jmp 0x24e34
movl $0x80000000, %ecx       # imm = 0x80000000
andl 0x9bc(%rbx), %ecx
movl (%rbx), %edx
movl %edx, %esi
andl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
orl %ecx, %esi
andl $0x1, %edx
movl (%rax,%rdx,4), %eax
xorl 0x630(%rbx), %eax
shrl %esi
xorl %esi, %eax
movl %eax, 0x9bc(%rbx)
xorl %eax, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x9c0(%rbx)
movl %eax, %eax
movl (%rbx,%rax,4), %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0x7, %eax
andl $0x9d2c5680, %eax       # imm = 0x9D2C5680
xorl %ecx, %eax
movl %eax, %ecx
shll $0xf, %ecx
andl $0xefc60000, %ecx       # imm = 0xEFC60000
xorl %eax, %ecx
movl %ecx, %eax
shrl $0x12, %eax
xorl %ecx, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
cmpq %rdx, %rsi
cmovbq %rsi, %rdx
movq %rdx, %xmm1
punpckldq 0x75bc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x75c4(%rip), %xmm1     # 0x2d170
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movapd %xmm0, (%rsp)
callq 0x9080
callq 0x98f0
addsd 0x8721(%rip), %xmm0     # 0x2e2f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x25bf7
movapd (%rsp), %xmm0
callq 0x9080
callq 0x98f0
addsd 0x8700(%rip), %xmm0     # 0x2e2f0
cvttsd2si %xmm0, %rax
jmp 0x25bf9
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq $0x3, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
movq $0x2, 0x30(%rbx)
movaps 0x86b7(%rip), %xmm0     # 0x2e2d0
movups %xmm0, 0x38(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25c91
leaq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
cmpq 0x8(%rdx), %rsi
jne 0x25c91
movq 0x10(%rcx), %rsi
cmpq 0x10(%rdx), %rsi
jne 0x25c91
movq 0x18(%rcx), %rsi
cmpq 0x18(%rdx), %rsi
jne 0x25c91
movq 0x20(%rcx), %rsi
cmpq 0x20(%rdx), %rsi
jne 0x25c91
movq 0x28(%rcx), %rsi
cmpq 0x30(%rdx), %rsi
jne 0x25c91
movsd 0x38(%rcx), %xmm0
ucomisd 0x38(%rdx), %xmm0
jne 0x25c91
jp 0x25c91
movsd 0x40(%rdx), %xmm0
cmpeqsd 0x40(%rcx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25cb6
movq (%rsi), %rax
movq 0x8(%rsi), %rsi
movl %edx, %ecx
shrq %cl, %rax
shrq %cl, %rsi
jmp 0x25cc7
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_O2/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
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9630
subq 0x10(%r15), %r14
movq 0x8(%r12), %rax
imulq (%r12), %rax
movq 0x48(%r15), %rcx
subq 0x28(%r15), %rbx
imulq %rax, %rbx
shlq $0x2, %rbx
addq (%rcx,%r14,8), %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x20, %rsp
movq 0x80(%rsp), %r12
movq 0x60(%rsp), %r15
movq 0x68(%rsp), %r14
subq 0x78(%rsp), %r12
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x9960
testq %rax, %rax
je 0x25eb3
movq %rax, %rbx
leaq 0x50(%rsp), %rsi
subq %r15, %r14
incq %r14
pushq $0x9
popq %rcx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x9960
movq %rax, 0x48(%rbx)
testq %rax, %rax
je 0x25eab
incq %r12
movq 0x10(%rbx), %r14
shlq $0x2, %r12
leaq 0x8(%rsp), %r15
cmpq 0x18(%rbx), %r14
jg 0x25eb5
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9630
movq 0x8(%rsp), %rdi
imulq %r12, %rdi
imulq 0x10(%rsp), %rdi
callq 0x95e0
movq 0x10(%rbx), %r13
movq 0x48(%rbx), %rcx
leaq (,%r13,8), %rdx
subq %rdx, %rcx
movq %rax, (%rcx,%r14,8)
movq 0x48(%rbx), %rax
subq %rdx, %rax
cmpq $0x0, (%rax,%r14,8)
leaq 0x1(%r14), %r14
jne 0x25e32
jmp 0x25ea5
movq 0x10(%rbx), %rax
movq 0x48(%rbx), %rcx
shlq $0x3, %rax
subq %rax, %rcx
movq (%rcx,%r13,8), %rdi
testq %rdi, %rdi
je 0x25ea2
callq 0x95b0
incq %r13
cmpq 0x18(%rbx), %r13
jle 0x25e85
movq %rbx, %rdi
callq 0x95b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
pushq $0x9
popq %rcx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
callq 0x9920
movq %rax, %r14
testq %rax, %rax
je 0x25f4d
movq 0x10(%rbx), %r15
leaq 0x50(%rsp), %r12
cmpq 0x18(%rbx), %r15
jg 0x25f4d
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9630
movq 0x10(%rbx), %rax
movq 0x30(%rbx), %rdx
subq 0x28(%rbx), %rdx
incq %rdx
movq 0x48(%r14), %rcx
shlq $0x3, %rax
subq %rax, %rcx
movq (%rcx,%r15,8), %rdi
movq 0x48(%rbx), %rcx
subq %rax, %rcx
imulq 0x50(%rsp), %rdx
movq (%rcx,%r15,8), %rsi
imulq 0x58(%rsp), %rdx
shlq $0x2, %rdx
callq 0x95d0
incq %r15
jmp 0x25ef6
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x25fc9
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x25fba
movq 0x10(%rbx), %r14
movq 0x48(%rbx), %rdi
cmpq 0x18(%rbx), %r14
jg 0x25fb5
movq 0x10(%rbx), %rax
shlq $0x3, %rax
subq %rax, %rdi
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x25fb0
callq 0x95b0
incq %r14
jmp 0x25f8d
callq 0x95b0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x95b0
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9630
movq 0x28(%r14), %r13
cvtsi2sd %rbx, %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rbp), %r15
movq 0x8(%rbp), %rax
movq %rax, 0x20(%rsp)
movsd 0x10(%rbp), %xmm0
movsd %xmm0, 0x18(%rsp)
cmpq 0x30(%r14), %r13
jge 0x26145
movsd 0x38(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x1(%r13), %rbp
cvtsi2sd %rbp, %xmm0
movsd 0x20(%r14), %xmm1
movsd 0x711b(%rip), %xmm2     # 0x2d160
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x7120(%rip), %xmm2     # 0x2d170
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 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%r14), %xmm0
movsd %xmm0, 0x28(%rsp)
cvtsi2sd %r13, %xmm0
movsd 0x20(%r14), %xmm1
unpcklps 0x70c7(%rip), %xmm1     # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x70cf(%rip), %xmm1     # 0x2d170
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
addsd 0x10(%rsp), %xmm0
callq 0x9040
mulsd 0x28(%rsp), %xmm0
mulsd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm1
subsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
ucomiss 0x78d1(%rip), %xmm0     # 0x2d9b0
jb 0x260e7
sqrtss %xmm0, %xmm0
jmp 0x260ec
callq 0x9610
cvtss2sd %xmm0, %xmm0
divsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x9050
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x9050
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r15, %rcx
movq 0x20(%rsp), %r8
movq %r15, %r9
movsd 0x8(%rsp), %xmm0
movaps %xmm0, %xmm1
callq 0x97d0
movq %rbp, %r13
jmp 0x26018
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/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:
movq %rcx, %rax
pushq $0x1
popq %r9
movl %r8d, %ecx
shll %cl, %r9d
testq %r8, %r8
je 0x26653
movslq %r9d, %rcx
cltq
movl %edx, %r8d
subl %ecx, %r8d
incl %r8d
movslq %r8d, %r8
imulq %rcx, %rdx
shlq $0x2, %rdx
xorl %r9d, %r9d
cmpq %rax, %r9
jge 0x26652
xorl %r10d, %r10d
cmpq %r8, %r10
jge 0x2664a
movss (%rsi,%r10,4), %xmm0
movss %xmm0, (%rdi)
addq $0x4, %rdi
addq %rcx, %r10
jmp 0x26632
addq %rcx, %r9
addq %rdx, %rsi
jmp 0x2662a
retq
imulq %rax, %rdx
shlq $0x2, %rdx
jmp 0x95d0
// File: /workspace/github_c_makefile_star2_O2/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 0x26943
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x268f1
callq 0x95b0
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x26902
callq 0x95b0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x26910
callq 0x95b0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2691e
callq 0x95b0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2692c
callq 0x95b0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2693a
callq 0x95b0
movq %rbx, %rdi
popq %rbx
jmp 0x95b0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edx, %r10d
imull %ecx, %r10d
decl %edx
movslq %ecx, %rax
addl %r10d, %r10d
xorl %ecx, %ecx
testl %edx, %edx
cmovlel %ecx, %edx
testl %eax, %eax
movl $0x0, %r8d
cmovgl %eax, %r8d
leaq (,%rax,8), %r9
movslq %r10d, %r11
shlq $0x2, %r11
movq %r9, %r10
subq %r11, %r10
orq $0x4, %r10
movss 0x6727(%rip), %xmm0     # 0x2d328
cmpl %r8d, %ecx
je 0x26c48
movss (%rsi), %xmm1
addq $0x4, %rsi
movl %edx, %r11d
subl $0x1, %r11d
jb 0x26c38
movss (%rsi), %xmm2
movss %xmm1, (%rdi)
addss %xmm2, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rdi,%rax,4)
addq $0x4, %rsi
addq %r9, %rdi
movaps %xmm2, %xmm1
jmp 0x26c11
movss %xmm1, (%rdi)
movss %xmm1, (%rdi,%rax,4)
addq %r10, %rdi
incl %ecx
jmp 0x26c01
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %ecx, %eax
pushq $0x1
popq %r9
movl %r8d, %ecx
shll %cl, %r9d
movslq %edx, %rcx
subl %r9d, %edx
incl %edx
movslq %r9d, %r8
cltq
imulq %r8, %rcx
shlq $0x2, %rcx
xorl %r9d, %r9d
cmpq %rax, %r9
jge 0x26c95
xorl %r10d, %r10d
cmpl %edx, %r10d
jge 0x26c8d
movss (%rsi,%r10,4), %xmm0
movss %xmm0, (%rdi)
addq $0x4, %rdi
addq %r8, %r10
jmp 0x26c75
addq %r8, %r9
addq %rcx, %rsi
jmp 0x26c6d
retq
// File: /workspace/github_c_makefile_star2_O2/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:
ucomisd 0x5a84(%rip), %xmm0     # 0x2e330
jbe 0x288b3
xorpd %xmm0, %xmm0
retq
mulsd 0x5a7d(%rip), %xmm0     # 0x2e338
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
xorpd %xmm2, %xmm2
cmpnlepd %xmm0, %xmm2
cmpneqpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movq %xmm1, %rcx
addq %rax, %rcx
cvtsi2sd %ecx, %xmm1
subsd %xmm1, %xmm0
movslq %ecx, %rax
shlq $0x20, %rcx
leaq 0xee6b(%rip), %rdx      # 0x37760
movsd (%rdx,%rax,8), %xmm2
movabsq $0x100000000, %rax      # imm = 0x100000000
addq %rcx, %rax
sarq $0x1d, %rax
movsd (%rax,%rdx), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/vl/sift.c
// Function: normalize_histogram
VL_INLINE vl_sift_pix
normalize_histogram
(vl_sift_pix *begin, vl_sift_pix *end)
{
  vl_sift_pix* iter ;
  vl_sift_pix  norm = 0.0 ;

  for (iter = begin ; iter != end ; ++ iter)
    norm += (*iter) * (*iter) ;

  norm = vl_fast_sqrt_f (norm) + VL_EPSILON_F ;

  for (iter = begin; iter != end ; ++ iter)
    *iter /= norm ;

  return norm;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rdi, %rax
cmpq %rbx, %rax
je 0x28f62
movss (%rax), %xmm1
mulss %xmm1, %xmm1
addss %xmm1, %xmm0
addq $0x4, %rax
jmp 0x28f4b
callq 0x296f8
addss 0x43bd(%rip), %xmm0     # 0x2d32c
cmpq %rbx, %r14
je 0x28f88
movss (%r14), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%r14)
addq $0x4, %r14
jmp 0x28f6f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x45a8(%rip), %xmm0     # 0x2db98
addsd %xmm2, %xmm0
divsd 0x8(%rdi), %xmm0
callq 0x9450
divsd 0x4cf2(%rip), %xmm0     # 0x2e2f8
movl 0x34(%r15), %ebp
cvtsi2sd %ebp, %xmm2
movsd 0x3baa(%rip), %xmm5     # 0x2d1c0
cvtsi2sdl 0x2c(%r15), %xmm1
addsd %xmm5, %xmm2
divsd %xmm1, %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
cvttsd2si %xmm3, %r14
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
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 0x3b9a(%rip), %xmm0     # 0x2d238
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 0x39ea(%rip), %xmm2     # 0x2d0b0
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
// File: /workspace/github_c_makefile_star2_O2/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 0x40a3(%rip), %rsi      # 0x2e3c0
callq 0x9ab0
testq %rax, %rax
je 0x2a368
movq %rax, %r14
movq %rax, %r12
subq %r15, %r12
leaq 0x408d(%rip), %rsi      # 0x2e3c4
movq %r15, %rdi
movq %r12, %rdx
callq 0x90e0
testl %eax, %eax
je 0x2a372
leaq 0x407d(%rip), %rsi      # 0x2e3ca
movq %r15, %rdi
movq %r12, %rdx
callq 0x90e0
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
testq %rbx, %rbx
je 0x2a37c
orl $0x2, %ecx
jmp 0x2a37a
testq %rbx, %rbx
je 0x2a383
andl $0x0, (%rbx)
jmp 0x2a383
testq %rbx, %rbx
je 0x2a37c
pushq $0x1
popq %rcx
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_O2/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, %r13
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
leaq 0x1(%r12), %rax
movzbl -0x1(%r14,%rax), %ecx
testl %ecx, %ecx
je 0x2a3e6
cmpl $0x2f, %ecx
je 0x2a3e1
cmpl $0x5c, %ecx
je 0x2a3e1
incq %rax
jmp 0x2a3c8
movq %rax, %r12
jmp 0x2a3c3
movq %r14, %rdi
callq 0x9320
movq %rax, %rcx
decq %rcx
leaq 0x1(%rcx), %rdx
cmpq %r12, %rdx
jbe 0x2a41e
cmpb $0x2e, (%r14,%rcx)
sete %dl
testq %r13, %r13
setne %sil
andb %dl, %sil
movzbl %sil, %edx
subq %rdx, %r13
testb %dl, %dl
cmovneq %rcx, %rax
jmp 0x2a3f1
addq %r14, %r12
addq %r14, %rax
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %rax, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x9a10
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
leaq (%rdx,%rax), %r8
cmpq %rcx, %r8
jae 0x2a475
movb (%r8), %r8b
testb %r8b, %r8b
je 0x2a475
testq %rdi, %rdi
setne %r10b
leaq 0x1(%rax), %r9
cmpq %rsi, %r9
setb %r11b
andb %r10b, %r11b
cmpb $0x1, %r11b
jne 0x2a470
movb %r8b, (%rdi,%rax)
movq %r9, %rax
jmp 0x2a440
testq %rsi, %rsi
je 0x2a488
decq %rsi
cmpq %rsi, %rax
cmovbq %rax, %rsi
movb $0x0, (%rdi,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
xorl %r10d, %r10d
movq %r10, %rax
movb $0x1, %bl
movb (%rdx), %r11b
testb %r11b, %r11b
je 0x2a517
movl %ebx, %r10d
incq %rdx
cmpb %r8b, %r11b
sete %bpl
xorl %ebx, %ebx
testb %bpl, %r10b
jne 0x2a495
cmpb %cl, %r11b
setne %bl
notb %r10b
orb %bl, %r10b
testb $0x1, %r10b
jne 0x2a4f4
movq %r9, %r11
movq %rax, %r10
movb (%r11), %bl
incq %r11
testb %bl, %bl
je 0x2a490
testq %rdi, %rdi
setne %bpl
leaq 0x1(%r10), %rax
cmpq %rsi, %rax
setb %r14b
andb %bpl, %r14b
cmpb $0x1, %r14b
jne 0x2a4c6
movb %bl, (%rdi,%r10)
jmp 0x2a4c6
testq %rdi, %rdi
setne %bl
leaq 0x1(%rax), %r10
cmpq %rsi, %r10
setb %bpl
andb %bl, %bpl
cmpb $0x1, %bpl
jne 0x2a490
movb %r11b, (%rdi,%rax)
jmp 0x2a490
testq %rsi, %rsi
je 0x2a52a
decq %rsi
cmpq %rsi, %rax
cmovbq %rax, %rsi
movb $0x0, (%rdi,%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %r8d, %r8d
movq %r8, %rax
movb (%rdx,%r8), %cl
testb %cl, %cl
je 0x2a55d
testq %rdi, %rdi
setne %r9b
leaq 0x1(%rax), %r8
cmpq %rsi, %r8
setb %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x2a532
movb %cl, (%rdi,%rax)
jmp 0x2a532
testq %rsi, %rsi
je 0x2a570
decq %rsi
cmpq %rsi, %rax
cmovbq %rax, %rsi
movb $0x0, (%rdi,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9b20
movq (%rax), %rcx
xorl %edx, %edx
movzbl (%r14,%rdx), %esi
movl (%rcx,%rsi,4), %eax
movzbl (%rbx,%rdx), %edi
subl (%rcx,%rdi,4), %eax
jne 0x2a5c6
testb %sil, %sil
je 0x2a5c4
incq %rdx
jmp 0x2a5a9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq