LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./potracelib.h
// Function: privcurve_init
int privcurve_init(privcurve_t *curve, int n) {
  memset(curve, 0, sizeof(privcurve_t));
  curve->n = n;
  SAFE_CALLOC(curve->tag, n, int);
  SAFE_CALLOC(curve->c, n, dpoint3_t);
  SAFE_CALLOC(curve->vertex, n, dpoint_t);
  SAFE_CALLOC(curve->alpha, n, double);
  SAFE_CALLOC(curve->alpha0, n, double);
  SAFE_CALLOC(curve->beta, n, double);
  return 0;
 calloc_error:
  free(curve->tag);
  free(curve->c);
  free(curve->vertex);
  free(curve->alpha);
  free(curve->alpha0);
  free(curve->beta);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movl %esi, (%rdi)
movslq %esi, %r13
movl $0x4, %esi
movq %r13, %rdi
callq 0x1110
movq %rax, %rbx
movq %rax, 0x8(%rbp)
testq %rax, %rax
je 0x7e84
movl $0x30, %esi
movq %r13, %rdi
callq 0x1110
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x7e84
movq %rax, %r14
movl $0x10, %esi
movq %r13, %rdi
callq 0x1110
movq %rax, 0x20(%rbp)
testq %rax, %rax
je 0x7ed0
movq %rax, %r15
movl $0x8, %esi
movq %r13, %rdi
callq 0x1110
movq %rax, 0x28(%rbp)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x7edb
movl $0x8, %esi
movq %r13, %rdi
callq 0x1110
movq %rax, 0x30(%rbp)
xorl %r12d, %r12d
testq %rax, %rax
je 0x7e7d
movq %rax, 0x10(%rsp)
movl $0x8, %esi
movq %r13, %rdi
callq 0x1110
movq %rax, 0x38(%rbp)
testq %rax, %rax
jne 0x7ebe
movq 0x10(%rsp), %r12
movq 0x8(%rsp), %r13
jmp 0x7e90
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq %r13, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
movl $0x1, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
jmp 0x7e90
xorl %r12d, %r12d
xorl %r13d, %r13d
jmp 0x7e90
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./potracelib.h
// Function: xor_path
static void xor_path(potrace_bitmap_t *bm, path_t *p) {
  int xa, x, y, k, y1;
  if (p->priv->len <= 0) {  /* a path of length 0 is silly, but legal */
    return;
  }
  y1 = p->priv->pt[p->priv->len-1].y;
  xa = p->priv->pt[0].x & -BM_WORDBITS;
  for (k=0; k<p->priv->len; k++) {
    x = p->priv->pt[k].x;
    y = p->priv->pt[k].y;
    if (y != y1) {
      /* efficiently invert the rectangle [x,xa] x [y,y1] */
      xor_to_ref(bm, x, min(y,y1), xa);
      y1 = y;
    }
  }
}

// Assembly:
movslq (%rsi), %rax
testq %rax, %rax
jle 0xc0fb
pushq %rbp
pushq %r14
pushq %rbx
movq 0x8(%rsi), %rdx
movq %rax, %rcx
shlq $0x4, %rcx
movl -0x8(%rdx,%rcx), %r10d
movl (%rdx), %esi
andl $-0x40, %esi
xorl %r8d, %r8d
movq %r8, %r9
shlq $0x4, %r9
leaq (%rdx,%r9), %rcx
movl 0x8(%rdx,%r9), %r9d
cmpl %r9d, %r10d
jne 0xc051
movl %r10d, %r9d
jmp 0xc0e8
cmovgel %r9d, %r10d
movl (%rcx), %r11d
movl %r11d, %ecx
andl $-0x40, %ecx
cmpl %esi, %ecx
jge 0xc08a
movslq %r10d, %r14
movslq 0x8(%rdi), %rbx
imulq %r14, %rbx
shlq $0x3, %rbx
addq 0x10(%rdi), %rbx
movl %ecx, %ebp
sarl $0x6, %ebp
movslq %ebp, %r14
notq (%rbx,%r14,8)
addl $0x40, %ecx
cmpl %esi, %ecx
jl 0xc075
jmp 0xc0b6
jle 0xc0b6
movslq %r10d, %r14
movslq 0x8(%rdi), %rbx
imulq %r14, %rbx
shlq $0x3, %rbx
addq 0x10(%rdi), %rbx
movl %esi, %ebp
movl %ebp, %r14d
sarl $0x6, %r14d
movslq %r14d, %r14
notq (%rbx,%r14,8)
addl $0x40, %ebp
cmpl %ecx, %ebp
jl 0xc0a1
movl %r11d, %ecx
andl $0x3f, %ecx
je 0xc0e8
negb %cl
movq $-0x1, %rbx
shlq %cl, %rbx
movslq %r10d, %rcx
movslq 0x8(%rdi), %r10
imulq %rcx, %r10
shlq $0x3, %r10
addq 0x10(%rdi), %r10
sarl $0x6, %r11d
movslq %r11d, %rcx
xorq %rbx, (%r10,%rcx,8)
incq %r8
movl %r9d, %r10d
cmpq %rax, %r8
jne 0xc034
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./potracelib.h
// Function: potrace_param_default
potrace_param_t *potrace_param_default(void) {
  potrace_param_t *p;
  p = (potrace_param_t *) malloc(sizeof(potrace_param_t));
  if (!p) {
    return NULL;
  }
  memcpy(p, &param_default, sizeof(potrace_param_t));
  return p;
}

// Assembly:
pushq %rax
movl $0x48, %edi
callq 0x1180
testq %rax, %rax
je 0xc11e
leaq 0x12585(%rip), %rsi     # 0x1e698
movl $0x9, %ecx
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./stb_image_resize.h
// Function: stbir__filter_catmullrom
static float stbir__filter_catmullrom(float x, float s)
{
    STBIR__UNUSED_PARAM(s);

    x = (float)fabs(x);

    if (x < 1.0f)
        return 1 - x*x*(2.5f - 1.5f*x);
    else if (x < 2.0f)
        return 2 - x*(4 + x*(0.5f*x - 2.5f));

    return (0.0f);
}

// Assembly:
movaps 0x394f(%rip), %xmm2     # 0x1e3a0
andps %xmm0, %xmm2
movss 0x35ac(%rip), %xmm1     # 0x1e008
ucomiss %xmm2, %xmm1
jbe 0x1aa85
movss 0x3603(%rip), %xmm3     # 0x1e06c
mulss %xmm2, %xmm3
addss 0x35fb(%rip), %xmm3     # 0x1e070
mulss %xmm0, %xmm0
mulss %xmm3, %xmm0
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
movss 0x35a3(%rip), %xmm0     # 0x1e030
ucomiss %xmm2, %xmm0
jbe 0x1aabb
movss 0x358a(%rip), %xmm1     # 0x1e024
mulss %xmm2, %xmm1
addss 0x35c2(%rip), %xmm1     # 0x1e068
mulss %xmm2, %xmm1
addss 0x35b2(%rip), %xmm1     # 0x1e064
mulss %xmm2, %xmm1
subss %xmm1, %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./stb_image_resize.h
// Function: stbir__edge_wrap
stbir__inline static int stbir__edge_wrap(stbir_edge edge, int n, int max)
{
    // avoid per-pixel switch
    if (n >= 0 && n < max)
        return n;
    return stbir__edge_wrap_slow(edge, n, max);
}

// Assembly:
movl %edx, %ecx
testl %esi, %esi
setns %al
cmpl %edx, %esi
setl %dl
testb %dl, %al
je 0x1c8a1
movl %esi, %eax
retq
decl %edi
cmpl $0x3, %edi
ja 0x1c901
xorl %eax, %eax
leaq 0x1cdb(%rip), %rdx      # 0x1e58c
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
testl %esi, %esi
js 0x1c8ea
leal -0x1(%rcx), %eax
cmpl %ecx, %esi
cmovll %esi, %eax
retq
testl %esi, %esi
js 0x1c8eb
cmpl %ecx, %esi
jl 0x1c89e
leal (%rcx,%rcx), %eax
xorl %edx, %edx
cmpl %esi, %eax
notl %esi
leal (%rsi,%rcx,2), %eax
cmovlel %edx, %eax
retq
movl %esi, %eax
cltd
idivl %ecx
movl %edx, %eax
testl %esi, %esi
js 0x1c8f3
retq
cmpl %ecx, %esi
jge 0x1c8fc
negl %esi
jmp 0x1c89e
addl %eax, %ecx
testl %eax, %eax
cmovel %eax, %ecx
jmp 0x1c8fe
decl %ecx
movl %ecx, %eax
retq
pushq %rax
leaq 0x5cb3(%rip), %rdi      # 0x225bc
leaq 0x5474(%rip), %rsi      # 0x21d84
leaq 0x5cc0(%rip), %rcx      # 0x225d7
movl $0x3e3, %edx            # imm = 0x3E3
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/yui0[P]img2vec/./potracelib.h
// Function: tangent
static double tangent(dpoint_t p0, dpoint_t p1, dpoint_t p2, dpoint_t p3, dpoint_t q0, dpoint_t q1) {
  double A, B, C;   /* (1-t)^2 A + 2(1-t)t B + t^2 C = 0 */
  double a, b, c;   /* a t^2 + b t + c = 0 */
  double d, s, r1, r2;
  A = cprod(p0, p1, q0, q1);
  B = cprod(p1, p2, q0, q1);
  C = cprod(p2, p3, q0, q1);
  a = A - 2*B + C;
  b = -2*A + 2*B;
  c = A;
  
  d = b*b - 4*a*c;
  if (a==0 || d<0) {
    return -1.0;
  }
  s = sqrt(d);
  r1 = (-b + s) / (2 * a);
  r2 = (-b - s) / (2 * a);
  if (r1 >= 0 && r1 <= 1) {
    return r1;
  } else if (r2 >= 0 && r2 <= 1) {
    return r2;
  } else {
    return -1.0;
  }
}

// Assembly:
subq $0x28, %rsp
movsd 0x48(%rsp), %xmm9
movsd 0x40(%rsp), %xmm8
subsd %xmm4, %xmm6
movapd %xmm4, %xmm10
subsd %xmm2, %xmm10
subsd %xmm0, %xmm2
subsd %xmm5, %xmm7
subsd %xmm3, %xmm5
subsd 0x30(%rsp), %xmm8
subsd %xmm1, %xmm3
subsd 0x38(%rsp), %xmm9
mulsd %xmm8, %xmm3
mulsd %xmm9, %xmm2
subsd %xmm3, %xmm2
mulsd %xmm8, %xmm5
mulsd %xmm9, %xmm10
subsd %xmm5, %xmm10
mulsd %xmm7, %xmm8
mulsd %xmm9, %xmm6
subsd %xmm8, %xmm6
addsd %xmm10, %xmm10
movapd %xmm2, %xmm5
subsd %xmm10, %xmm5
addsd %xmm6, %xmm5
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm5
movsd 0x3999(%rip), %xmm0     # 0x20b98
jne 0x1d207
jnp 0x1d2ec
movapd %xmm2, %xmm1
addsd %xmm2, %xmm1
subsd %xmm1, %xmm10
movsd 0x3a24(%rip), %xmm4     # 0x20c40
mulsd %xmm5, %xmm4
mulsd %xmm2, %xmm4
movapd %xmm10, %xmm1
mulsd %xmm10, %xmm1
addsd %xmm4, %xmm1
ucomisd %xmm1, %xmm3
ja 0x1d2ec
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jb 0x1d24c
sqrtsd %xmm1, %xmm1
jmp 0x1d277
movapd %xmm1, %xmm0
movapd %xmm10, 0x10(%rsp)
movsd %xmm5, 0x8(%rsp)
callq 0x1220
xorpd %xmm2, %xmm2
movsd 0x8(%rsp), %xmm5
movapd 0x10(%rsp), %xmm10
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
subsd %xmm10, %xmm0
addsd %xmm5, %xmm5
divsd %xmm5, %xmm0
ucomisd %xmm2, %xmm0
jb 0x1d29c
movsd 0x3922(%rip), %xmm2     # 0x20bb8
ucomisd %xmm0, %xmm2
jae 0x1d2ec
xorpd 0xeab(%rip), %xmm10     # 0x1e150
subsd %xmm1, %xmm10
divsd %xmm5, %xmm10
movapd %xmm10, %xmm1
cmplesd 0x38fb(%rip), %xmm1     # 0x20bb8
movapd %xmm1, %xmm0
andpd %xmm10, %xmm0
movsd 0x38ca(%rip), %xmm2     # 0x20b98
andnpd %xmm2, %xmm1
orpd %xmm0, %xmm1
xorpd %xmm0, %xmm0
cmplesd %xmm10, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/howerj[P]eweb/simple.c
// Function: main
int main(int argc, char **argv) {
	eweb_os_t w = eweb_os;
	if (argc != 2 || !strcmp(argv[1], "-h")) {
		printf("hint: %s [port number]\n", argv[0]);
		return EXIT_FAILURE;
	}
	return eweb_server(&w, atoi(argv[1]), simple_response) == EWEB_OK ? EXIT_SUCCESS : EXIT_FAILURE ;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x590f(%rip), %rsi      # 0x7d30
leaq 0x8(%rsp), %rdi
movl $0xa0, %edx
callq 0x2170
cmpl $0x2, %ebp
jne 0x246d
movq 0x8(%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x244a
cmpb $0x68, 0x1(%rdi)
jne 0x244a
cmpb $0x0, 0x2(%rdi)
je 0x246d
callq 0x2240
leaq 0x37(%rip), %rdx        # 0x248d
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x350c
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x2483
movq (%rbx), %rsi
leaq 0x2b8d(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x20b0
movl $0x1, %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: create_ht
HashTable *
create_ht(size_t size, size_t (*hash_f)(const void *, size_t))
{
  size_t ht_siz        = sizeof(HashTable);
  size_t buck_siz      = sizeof(Bucket) * size;
  size_t tail_buck_siz = sizeof(Bucket *) * size;
  size_t total_siz     = ht_siz + buck_siz + tail_buck_siz;

  char         *heap   = (char *)malloc(total_siz);
  HashTable    *ht     = (HashTable *)heap;

  memset(heap, 0, total_siz);

  ht->bucket      = (Bucket *)&(heap[ht_siz]);
  ht->size        = size;
  ht->item_c      = 0;
  ht->hash_f      = (hash_f == NULL) ? default_ht_hash_f : hash_f;
  ht->tail_bucket = (Bucket **)&(heap[ht_siz + buck_siz]);

  return ht;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r15
shlq $0x4, %r15
leaq (%r15,%rdi,8), %rsi
addq $0x28, %rsi
movl $0x1, %edi
callq 0x1090
leaq 0x28(%rax), %rcx
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
testq %rbx, %rbx
leaq -0x55(%rip), %rcx       # 0x11dc
cmovneq %rbx, %rcx
movq %rcx, 0x20(%rax)
leaq (%rax,%r15), %rcx
addq $0x28, %rcx
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: free_ht
void
free_ht(HashTable *ht)
{
  size_t ht_siz = ht->size;

  for (size_t i = 0; i < ht_siz; i++) {
    Bucket *rbuck;
    Bucket *prev;

    if (ht->tail_bucket[i] == NULL) {
      continue;
    }

    /* Free the first bucket slot. */
    rbuck = &(ht->bucket[i]);
    free(rbuck->item);

    /* Now traverse the next slot. */
    rbuck = rbuck->next;

    while (rbuck != NULL) {
      free(rbuck->item);
      prev  = rbuck;
      rbuck = rbuck->next;
      free(prev);
    }
  }

  free(ht);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x12af
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax,%r12,8)
je 0x12a7
movq (%rbx), %r14
movq %r12, %r13
shlq $0x4, %r13
movq (%r14,%r13), %rdi
callq 0x1030
movq 0x8(%r14,%r13), %r14
testq %r14, %r14
je 0x12a7
movq (%r14), %rdi
callq 0x1030
movq 0x8(%r14), %r13
movq %r14, %rdi
callq 0x1030
movq %r13, %r14
testq %r13, %r13
jne 0x128b
incq %r12
cmpq %r15, %r12
jne 0x1263
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: insert_item_ht
void
insert_item_ht(HashTable *ht, const void *key, size_t key_len,
               const void *data, size_t data_len)
{
  char   *heap;
  size_t hash;
  size_t index;
  Item   *item;
  Bucket *tail;

  assert(ht->hash_f != NULL);

  hash  = ht->hash_f(key, key_len);
  index = hash % ht->size;
  heap  = (char *)malloc(sizeof(Item) + key_len + data_len);
  item  = (Item *)heap;

  item->key       = (void *)&(heap[sizeof(Item)]);
  item->key_len   = key_len;
  item->data      = (void *)&(heap[sizeof(Item) + key_len]);
  item->data_len  = data_len;

  memcpy(item->key, key, key_len);
  memcpy(item->data, data, data_len);

  tail = ht->tail_bucket[index];

  if (unlikely(tail != NULL)) {
    /* We have hash collision. */
    Bucket *key_col;

    key_col = find_bucket_slot(&(ht->bucket[index]), key, key_len);
    if (key_col == NULL) {
      tail->next = (Bucket *)malloc(sizeof(Bucket));
      tail       = tail->next;
    } else {
      /* Don't update tail, we only replace item. */
      free(key_col->item);
      key_col->item = item;
      return;
    }
  } else {
    tail       = &(ht->bucket[index]);
    assert(tail->next == NULL);
  }

  tail->item = item;
  tail->next = NULL;
  ht->tail_bucket[index] = tail;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x13bc
movq %r8, %rbp
movq %rdx, %r15
movq %rdi, %r13
movq %rsi, %rdi
movq %rsi, %rbx
movq %rdx, %rsi
callq *%rax
xorl %edx, %edx
divq 0x10(%r13)
movq %rdx, 0x8(%rsp)
leaq (%r15,%rbp), %rdi
addq $0x20, %rdi
callq 0x10c0
movq %rax, %r14
leaq 0x20(%rax), %rdi
movq %rdi, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rax,%r15), %r12
movq %r12, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %rbx, (%rsp)
movq %rbx, %rsi
movq 0x8(%rsp), %rbx
movq %r15, %rdx
callq 0x10b0
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0x10b0
movq 0x8(%r13), %r12
movq (%r12,%rbx,8), %rbp
movq %rbx, %rdi
shlq $0x4, %rdi
addq (%r13), %rdi
testq %rbp, %rbp
jne 0x1388
cmpq $0x0, 0x8(%rdi)
jne 0x13db
movq %r14, (%rdi)
movq $0x0, 0x8(%rdi)
movq %rdi, (%r12,%rbx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rsi
movq %r15, %rdx
callq 0x13fa
testq %rax, %rax
je 0x13a9
movq %rax, %r15
movq (%rax), %rdi
callq 0x1030
movq %r14, (%r15)
jmp 0x1379
movl $0x10, %edi
callq 0x10c0
movq %rax, %rdi
movq %rax, 0x8(%rbp)
jmp 0x136a
leaq 0xc41(%rip), %rdi       # 0x2004
leaq 0xc4d(%rip), %rsi       # 0x2017
leaq 0xc56(%rip), %rcx       # 0x2027
movl $0x6c, %edx
callq 0x1080
leaq 0xc92(%rip), %rdi       # 0x2074
leaq 0xc2e(%rip), %rsi       # 0x2017
leaq 0xc37(%rip), %rcx       # 0x2027
movl $0x8d, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: find_bucket_slot
Bucket *
find_bucket_slot(Bucket *rbuck, const void *key, size_t key_len)
{
  do {

    if (unlikely(rbuck->item == NULL)) {
      goto next_slot;
    }

    if (rbuck->item->key_len != key_len) {
      goto next_slot;
    }

    if (!memcmp(rbuck->item->key, key, key_len)) {
      return rbuck;
    }

  next_slot:
    rbuck = rbuck->next;
  } while (rbuck != NULL);


  /* Not Found. */
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x1428
cmpq %r14, 0x8(%rax)
jne 0x1428
movq (%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10d0
testl %eax, %eax
je 0x1433
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x1408
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: find_item_ht
Item *
find_item_ht(HashTable *ht, const void *key, size_t key_len)
{
  size_t hash;
  size_t index;
  Bucket *rbuck;

  assert(ht->hash_f != NULL);

  hash  = ht->hash_f(key, key_len);
  index = hash % ht->size;

  if (ht->tail_bucket[index] == NULL) {
    /* Not Found. */
    return NULL;
  }

  rbuck = find_bucket_slot(&(ht->bucket[index]), key, key_len);
  return (rbuck != NULL) ? rbuck->item : NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x14dd
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq *%rax
xorl %ecx, %ecx
xorl %edx, %edx
divq 0x10(%r15)
movq 0x8(%r15), %rax
cmpq $0x0, (%rax,%rdx,8)
je 0x14d4
shlq $0x4, %rdx
addq (%r15), %rdx
movq %rdx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13fa
testq %rax, %rax
je 0x14d2
movq (%rax), %rcx
jmp 0x14d4
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb20(%rip), %rdi       # 0x2004
leaq 0xb2c(%rip), %rsi       # 0x2017
leaq 0xb95(%rip), %rcx       # 0x2087
movl $0xd0, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: main
int
main()
{
  Item *item;
  HashTable *ht;
  struct timespec clock1, clock2;

  ht = create_ht(500000, NULL);
  ht_construct(ht);

  clock_gettime(CLOCK_MONOTONIC, &clock1);
  item = find_strstr_ht(ht, "SutNmukuaOWUZJaHtaayfBrwXkEvyURBdwiTXneTIvsVSkPlhWbYBxRmUhWaFnbdWqyAnqsxXqifoZsJIDiFqWVvlBrilzUbqcgR");
  clock_gettime(CLOCK_MONOTONIC, &clock2);
  printf("%8lli ms\n", tdiff(clock1, clock2)/1000000);


  if (item != NULL) {
    printf("%s\n", (char *)item->data);
  } else {
    printf("Not Found\n");
  }

  free_ht(ht);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl $0x1, %edi
movl $0xb71b28, %esi         # imm = 0xB71B28
callq 0x1090
movq %rax, %rbx
addq $0x28, %rax
movq %rax, (%rbx)
movq $0x7a120, 0x10(%rbx)    # imm = 0x7A120
leaq -0x3a1(%rip), %rax      # 0x11dc
movq %rax, 0x20(%rbx)
leaq 0x7a1228(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x10a0
leaq 0x10(%rsp), %r15
movl $0x1, %edi
movq %r15, %rsi
callq 0x1050
leaq 0xb10(%rip), %rsi       # 0x20bd
movl $0x65, %edx
movq %rbx, %rdi
callq 0x1481
movq %rax, %r14
movq %rsp, %r12
movl $0x1, %edi
movq %r12, %rsi
callq 0x1050
vmovdqa (%r12), %xmm0
vpsubq (%r15), %xmm0, %xmm0
vpextrq $0x1, %xmm0, %rax
leaq 0x3b9aca00(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x3f, %rax
vmovq %xmm0, %rdx
addq %rax, %rdx
imulq $0x3b9aca00, %rdx, %rax # imm = 0x3B9ACA00
addq %rcx, %rax
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x12, %rdx
addq %rdx, %rsi
leaq 0xafe(%rip), %rdi       # 0x2122
xorl %eax, %eax
callq 0x1070
testq %r14, %r14
je 0x1636
movq 0x10(%r14), %rdi
jmp 0x163d
leaq 0xaef(%rip), %rdi       # 0x212c
callq 0x1040
movq %rbx, %rdi
callq 0x124b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31.cpp
// Function: psk31::set_sample_rate(float)
void psk31::set_sample_rate(float sample_rate){

	this->sample_rate = sample_rate;

	ninty_deg_phase_width = (sample_rate/psk31freq)/4.0;

	bitwidth = sample_rate/bit_rate;

	if(input_data != NULL) delete input_data;

	input_data_width = (int)(bitwidth+ninty_deg_phase_width);
	input_data = new char[input_data_width];

	input_position = 0;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movss %xmm0, 0x8(%rdi)
movaps %xmm0, %xmm1
divss 0x10(%rdi), %xmm1
mulss 0x3e03(%rip), %xmm1     # 0x7094
movss %xmm1, 0x18(%rdi)
divss 0xc(%rdi), %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x1c(%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x32bd
movl $0x1, %esi
callq 0x21f0
movl 0x1c(%rbx), %eax
movss 0x18(%rbx), %xmm1
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
movl $0x0, 0x50(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31.cpp
// Function: psk31::set_bit_rate(float)
void psk31::set_bit_rate(float bit_rate){

	this->bit_rate = bit_rate;

	bitwidth = sample_rate/bit_rate;

	if(input_data != NULL) delete input_data;

	input_data_width = (int)(bitwidth+ninty_deg_phase_width);
	input_data = new char[input_data_width];

	input_position = 0;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movss %xmm0, 0xc(%rdi)
movss 0x8(%rdi), %xmm1
divss %xmm0, %xmm1
cvttss2si %xmm1, %eax
movl %eax, 0x1c(%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x3311
movl $0x1, %esi
callq 0x21f0
movl 0x1c(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
addss 0x18(%rbx), %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
movl $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31.cpp
// Function: psk31::set_psk31freq(float)
void psk31::set_psk31freq(float psk31freq){

	this->psk31freq = psk31freq;

	ninty_deg_phase_width = (sample_rate/psk31freq)/4.0;

	if(input_data != NULL) delete input_data;

	input_data_width = (int)(bitwidth+ninty_deg_phase_width);
	input_data = new char[input_data_width];

	input_position = 0;

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movss %xmm0, 0x10(%rdi)
movss 0x8(%rdi), %xmm1
divss %xmm0, %xmm1
mulss 0x3d44(%rip), %xmm1     # 0x7094
movss %xmm1, 0x18(%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x336d
movl $0x1, %esi
callq 0x21f0
movss 0x18(%rbx), %xmm1
xorps %xmm0, %xmm0
cvtsi2ssl 0x1c(%rbx), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
movl $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_tdtl.cpp
// Function: psk31_tdtl::psk31_tdtl()
psk31_tdtl::psk31_tdtl(){

	sample_rate = 22050;
	bit_rate = 31.25;
	psk31freq = 1900;

	init();

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3138
leaq 0x4e85(%rip), %rax      # 0x9cd8
movq %rax, (%rbx)
movsd 0x2252(%rip), %xmm0     # 0x70b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x4f1c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d8
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_tdtl.cpp
// Function: psk31_tdtl::psk31_tdtl(float, float, float)
psk31_tdtl::psk31_tdtl(float sample_rate, float bit_rate, float psk31freq){

	this->sample_rate = sample_rate;
	this->bit_rate = bit_rate;
	this->psk31freq = psk31freq;

	init();

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm2, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
callq 0x3138
leaq 0x4e22(%rip), %rax      # 0x9cd8
movq %rax, (%rbx)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rbx)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x4f1c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d8
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_tdtl.cpp
// Function: psk31_tdtl::init()
void psk31_tdtl::init(){

	initVaricode();

	ninty_deg_phase_width = (sample_rate/psk31freq)/4.0;

	bitwidth = (int)floor((floor((psk31freq/bit_rate)+0.5)*(sample_rate/psk31freq))+0.5);

	input_data_width = (int)(bitwidth+ninty_deg_phase_width);
	input_data = new char[input_data_width];

	input_position = 0;

	input_count = 0;

	max = 0;

	threshhold_value = 0.5;

	last = -1;
	countlast = 1;

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x33d0
movss 0x8(%rbx), %xmm2
movss 0x10(%rbx), %xmm0
divss %xmm0, %xmm2
movss %xmm2, 0x8(%rsp)
movss 0x214f(%rip), %xmm1     # 0x7094
mulss %xmm2, %xmm1
movss %xmm1, 0xc(%rsp)
movss %xmm1, 0x18(%rbx)
divss 0xc(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x216b(%rip), %xmm0     # 0x70d0
callq 0x2320
xorps %xmm1, %xmm1
cvtss2sd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x2151(%rip), %xmm0     # 0x70d0
callq 0x2320
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rbx)
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
addss 0xc(%rsp), %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
movq $0x0, 0x50(%rbx)
movl $0x3f000000, 0x14(%rbx) # imm = 0x3F000000
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x98(%rbx)
movl $0x1, 0xa0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_wcpd.cpp
// Function: psk31_wcpd::psk31_wcpd()
psk31_wcpd::psk31_wcpd(){

	sample_rate = 22050;
	bit_rate = 31.25;
	psk31freq = 1900;

	init();

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3138
leaq 0x4745(%rip), %rax      # 0x9d20
movq %rax, (%rbx)
movsd 0x1aca(%rip), %xmm0     # 0x70b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x56a4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d8
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_wcpd.cpp
// Function: psk31_wcpd::psk31_wcpd(float, float, float)
psk31_wcpd::psk31_wcpd(float sample_rate, float bit_rate, float psk31freq){

	this->sample_rate = sample_rate;
	this->bit_rate = bit_rate;
	this->psk31freq = psk31freq;

	init();

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movss %xmm2, 0x14(%rsp)
movss %xmm1, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
movq %rdi, %rbx
callq 0x3138
leaq 0x46e2(%rip), %rax      # 0x9d20
movq %rax, (%rbx)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8(%rbx)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0xc(%rbx)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x10(%rbx)
movq %rbx, %rdi
callq 0x56a4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d8
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_wcpd.cpp
// Function: psk31_wcpd::init()
void psk31_wcpd::init(){

	initVaricode();

	// Match Wave Phase against 1 full wavelength
	ninty_deg_phase_width = (sample_rate/psk31freq);

	bitwidth = (int)floor((floor((psk31freq/bit_rate)+0.5)*(sample_rate/psk31freq))+0.5);

	input_data_width = (int)(bitwidth+ninty_deg_phase_width);
	input_data = new char[input_data_width];

	input_position = 0;

	input_count = 0;

	max = 0;

	threshhold_value = 0.5;

	last = -1;
	countlast = 1;

}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x33d0
movss 0x8(%rbx), %xmm1
movss 0x10(%rbx), %xmm0
divss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movss %xmm1, 0x18(%rbx)
divss 0xc(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x19f5(%rip), %xmm0     # 0x70d0
callq 0x2320
xorps %xmm1, %xmm1
cvtss2sd 0xc(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x19db(%rip), %xmm0     # 0x70d0
callq 0x2320
cvttsd2si %xmm0, %eax
movl %eax, 0x1c(%rbx)
cvttpd2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
addss 0xc(%rsp), %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
movq $0x0, 0x50(%rbx)
movl $0x3f000000, 0x14(%rbx) # imm = 0x3F000000
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x98(%rbx)
movl $0x1, 0xa0(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/DrYerzinia[P]C_DigiMode/src/psk31/psk31_wpdd.cpp
// Function: psk31_wpdd::psk31_wpdd()
psk31_wpdd::psk31_wpdd(){

	sample_rate = 22050;
	bit_rate = 31.25;
	psk31freq = 1900;

	init();

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3138
leaq 0x4005(%rip), %rax      # 0x9d68
movq %rax, (%rbx)
movsd 0x1342(%rip), %xmm0     # 0x70b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x5e2c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d8
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O3/samtools[P]htslib/realn.c
// Function: realn_check_tag
static int realn_check_tag(const uint8_t *tg, enum htsLogLevel severity,
                           const char *type, const bam1_t *b) {
    if (*tg != 'Z') {
        hts_log(severity, __func__, "Incorrect %s tag type (%c) for read %s",
                type, *tg, bam_get_qname(b));
        return -1;
    }
    if (b->core.l_qseq != strlen((const char *) tg + 1)) {
        hts_log(severity, __func__, "Read %s %s tag is wrong length",
                bam_get_qname(b), type);
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movzbl (%rdi), %r8d
cmpl $0x5a, %r8d
jne 0x1a808
movslq 0x18(%r14), %r15
incq %rdi
callq 0x41d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
je 0x1a82b
movq 0x38(%r14), %rcx
leaq 0x77e51(%rip), %rsi     # 0x92644
leaq 0x77e81(%rip), %rdx     # 0x9267b
movl %ebp, %edi
movq %rbx, %r8
xorl %eax, %eax
callq 0xdf4d
jmp 0x1a826
movq 0x38(%r14), %r9
leaq 0x77e31(%rip), %rsi     # 0x92644
leaq 0x77e3a(%rip), %rdx     # 0x92654
movl %ebp, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xdf4d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/errors.c
// Function: ierror
void ierror(char *errtxt,...)
/* display internal error and quit */
{
  struct GlobalVars *gv = &gvars;
  va_list vl;

  fprintf(stderr,"\nINTERNAL ERROR: ");
  va_start(vl,errtxt);
  vfprintf(stderr,errtxt,vl);
  va_end(vl);
  fprintf(stderr,".\nAborting.\n");
  gv->returncode = EXIT_FAILURE;
  cleanup(gv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x5315
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x29cd4(%rip), %r12     # 0x2eff0
movq (%r12), %rcx
leaq 0x1b047(%rip), %rdi     # 0x2036e
pushq $0x11
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x5270
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r15, 0x10(%rdx)
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x5230
movq (%r12), %rcx
leaq 0x1b013(%rip), %rdi     # 0x20380
pushq $0xc
popq %rsi
movq %r14, %rdx
callq 0x5270
leaq 0x2b819(%rip), %rdi     # 0x30b98
movl $0x1, 0x11c(%rdi)
callq 0x558c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/main.c
// Function: get_option_arg
static char *get_option_arg(int argc,char *argv[],int *i)
/* get pointer to the string, which either directly follows the option
   character or is stored in the next argument */
{
  if (argv[*i][2])
    return &argv[*i][2];
  else {
    if (++*i<argc) {
      /* another option? */
      if (argv[*i][0]!='-' || isdigit((unsigned char)argv[*i][1]))
        return argv[*i];
    }
    --*i;
  }
  error(5,argv[*i][1]);
  return NULL;  /* not reached */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdx), %r12d
movslq %r12d, %rax
movq (%rsi,%rax,8), %r15
cmpb $0x0, 0x2(%r15)
je 0x6583
addq $0x2, %r15
movq %r15, %r14
jmp 0x65c7
movq %rdx, %rbx
leal 0x1(%r12), %ecx
movl %ecx, (%rdx)
cmpl %edi, %ecx
jge 0x65b0
movq 0x8(%rsi,%rax,8), %r14
cmpb $0x2d, (%r14)
jne 0x65c7
callq 0x5290
movq (%rax), %rax
movzbl 0x1(%r14), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x65c7
movl %r12d, (%rbx)
movsbl 0x1(%r15), %esi
xorl %r14d, %r14d
movl $0x5, %edi
xorl %eax, %eax
callq 0x6f14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/main.c
// Function: chk_flags
static uint16_t chk_flags(char *s)
/* check for input-file flags */
{
  if (!strcmp(s+5,"deluscore"))
    return IFF_DELUNDERSCORE;

  else if (!strcmp(s+5,"adduscore"))
    return IFF_ADDUNDERSCORE;

  error(2,s);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5(%rdi), %r14
leaq 0x19c8e(%rip), %rsi     # 0x20276
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0x661a
leaq 0x19c85(%rip), %rsi     # 0x20280
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0x6620
xorl %ebp, %ebp
movl $0x2, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6f14
jmp 0x6624
movw $0x1, %bp
jmp 0x6624
movw $0x2, %bp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: alloc
void *alloc(size_t size)
/* allocate memory and print error message if not enough available */
{
  void *p;

  if (!size)
    size = 1;
  if (!(p = malloc(size)))
    error(1);  /* out of memory */
  return p;
}

// Assembly:
pushq %rbx
cmpq $0x1, %rdi
adcq $0x0, %rdi
callq 0x51c0
movq %rax, %rbx
testq %rax, %rax
jne 0x665a
movl $0x1, %edi
xorl %eax, %eax
callq 0x6f14
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: re_alloc
void *re_alloc(void *old,size_t size)
/* reallocate memory block, preserve old contents */
{
  void *p;

  if (!size)
    size = 1;
  if (!(p = realloc(old,size)))
    error(1);  /* out of memory */
  return p;
}

// Assembly:
pushq %rbx
cmpq $0x1, %rsi
adcq $0x0, %rsi
callq 0x5200
movq %rax, %rbx
testq %rax, %rax
jne 0x6681
movl $0x1, %edi
xorl %eax, %eax
callq 0x6f14
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: mapfile
char *mapfile(const char *name)
/* Map a complete file into memory and return its address. */
/* The file's length is returned in *(p-sizeof(size_t)). */
/* The last byte is followed by a 0-byte, indicating EOF for */
/* functions which need it. */
{
  FILE *fp;
  char *p=NULL;
  size_t fsiz;

  if (fp = fopen(name,"rb")) {
    fsiz = filesize(fp,name);
    p = alloc(fsiz+sizeof(size_t)+1);
    *(size_t *)p = fsiz;  /* store file size before the text starts */
    p += sizeof(size_t);
    *(p+fsiz) = 0;        /* terminated by 0-byte */
    if (fread(p,1,fsiz,fp) != fsiz) {
      fclose(fp);
      error(7,name);  /* read error */
    }
    fclose(fp);
  }
  return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x19b18(%rip), %rsi     # 0x20295
callq 0x5220
testq %rax, %rax
je 0x683e
movq %rax, %r14
movq %rax, %rdi
callq 0x5190
testq %rax, %rax
js 0x67d2
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x51f0
testl %eax, %eax
js 0x67d2
movq %r14, %rdi
callq 0x5190
testq %rax, %rax
js 0x67d2
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x51f0
testl %eax, %eax
jns 0x67ec
movq %r14, %rdi
callq 0x50c0
xorl %r15d, %r15d
movl $0x5, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6f14
leaq 0x9(%r15), %rdi
callq 0x6638
movq %rax, %r12
movq %r15, (%rax)
movb $0x0, 0x8(%rax,%r15)
addq $0x8, %r12
movl $0x1, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x50b0
cmpq %r15, %rax
je 0x6834
movq %r14, %rdi
callq 0x50c0
movl $0x7, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6f14
movq %r14, %rdi
callq 0x50c0
jmp 0x6841
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: base_name
const char *base_name(const char *s)
/* returns last part of a path - the file name itself */
{
  char c;
  int l = strlen(s);

  while (l--) {
    c = s[l];
    if (c== '/' || c==':')
      return &s[l+1];
  }
  return s;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x50e0
movslq %eax, %rsi
shlq $0x20, %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rax, %rcx
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rsi, %rdx
subq $0x1, %rdx
jb 0x689c
movzbl -0x1(%rbx,%rsi), %edi
addq %rax, %rcx
cmpl $0x3a, %edi
je 0x6895
movq %rdx, %rsi
cmpl $0x2f, %edi
jne 0x687a
sarq $0x20, %rcx
addq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: checkrange
bool checkrange(lword val,bool sign,int size)
/* Checks if 'val' (signed or unsigned) fits into 'size' bits.
   Returns FALSE when 'val' is out of range! */
{
  if (size) {
    lword min = -(1LL<<(size-1));
    lword max = sign ? ((1LL<<(size-1))-1LL) : ((1LL<<size)-1LL);

    if (val<min || val>max)
      return FALSE;

    return TRUE;
  }

  ierror("checkrange(): size==0 (val=%lld)\n",val);
  return FALSE;  /* size==0 is illegal */
}

// Assembly:
pushq %rbx
movq %rdi, %rax
testl %edx, %edx
je 0x68f4
leal -0x1(%rdx), %ecx
movl $0x1, %edi
shlq %cl, %rdi
movq %rdi, %r8
movq $-0x1, %r9
movl %edx, %ecx
shlq %cl, %r9
negq %r8
decq %rdi
testl %esi, %esi
notq %r9
cmovneq %rdi, %r9
cmpq %rax, %r8
setle %cl
cmpq %rax, %r9
setge %al
andb %cl, %al
movzbl %al, %ebx
jmp 0x6907
leaq 0x1999d(%rip), %rdi     # 0x20298
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x52b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: write32
void write32(bool be,void *p,uint32_t d)
{
  if (be)
    write32be(p,d);
  else
    write32le(p,d);
}

// Assembly:
movl %edx, %eax
shrl $0x10, %eax
testl %edi, %edi
je 0x69b7
movl %edx, %ecx
shrl $0x18, %ecx
movl %eax, %edi
movl %edx, %eax
shrl $0x8, %eax
jmp 0x69c1
movl %edx, %edi
shrl $0x8, %edi
movl %edx, %ecx
shrl $0x18, %edx
movb %cl, (%rsi)
movb %dil, 0x1(%rsi)
movb %al, 0x2(%rsi)
movb %dl, 0x3(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: write64
void write64(bool be,void *p,uint64_t d)
{
  if (be)
    write64be(p,d);
  else
    write64le(p,d);
}

// Assembly:
movq %rdx, %rax
shrq $0x20, %rax
testl %edi, %edi
je 0x6a08
movq %rdx, %r8
shrq $0x38, %r8
movq %rdx, %rcx
shrq $0x30, %rcx
movq %rdx, %rdi
shrq $0x28, %rdi
movq %rax, %r9
movq %rdx, %rax
shrq $0x18, %rax
movq %rdx, %r10
shrq $0x10, %r10
movq %rdx, %r11
shrq $0x8, %r11
jmp 0x6a32
movq %rdx, %rcx
shrq $0x8, %rcx
movq %rdx, %rdi
shrq $0x10, %rdi
movq %rdx, %r9
shrq $0x18, %r9
movq %rdx, %r10
shrq $0x28, %r10
movq %rdx, %r11
shrq $0x30, %r11
movq %rdx, %r8
shrq $0x38, %rdx
movb %r8b, (%rsi)
movb %cl, 0x1(%rsi)
movb %dil, 0x2(%rsi)
movb %r9b, 0x3(%rsi)
movb %al, 0x4(%rsi)
movb %r10b, 0x5(%rsi)
movb %r11b, 0x6(%rsi)
movb %dl, 0x7(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: writetaddr
int writetaddr(struct GlobalVars *gv,void *p,lword d)
{
  bool be = fff[gv->dest_format]->endianess == _BIG_ENDIAN_;

  switch (fff[gv->dest_format]->addr_bits) {
    case 16:
      write16(be,p,(uint16_t)d);
      return 2;
    case 32:
      write32(be,p,(uint32_t)d);
      return 4;
    case 64:
      write64(be,p,(uint64_t)d);
      return 8;
    default:
      ierror("writetaddr(): target address has %d bits",
             (int)fff[gv->dest_format]->addr_bits);
      break;
  }
  return 0;
}

// Assembly:
pushq %rbx
movzbl 0x50(%rdi), %eax
leaq 0x28725(%rip), %rcx     # 0x2f180
movq (%rcx,%rax,8), %rax
movb 0xaa(%rax), %cl
movzbl 0xab(%rax), %eax
cmpl $0x40, %eax
je 0x6aad
cmpl $0x20, %eax
je 0x6a95
cmpl $0x10, %eax
jne 0x6ac2
cmpb $0x1, %cl
movzbl %dh, %eax
movl %eax, %ecx
cmovel %edx, %ecx
cmovel %eax, %edx
movb %dl, (%rsi)
movb %cl, 0x1(%rsi)
movl $0x2, %ebx
jmp 0x6af2
movl %edx, %eax
shrl $0x10, %eax
cmpb $0x1, %cl
jne 0x6ad7
movl %edx, %ecx
shrl $0x18, %ecx
movl %eax, %edi
movl %edx, %eax
shrl $0x8, %eax
jmp 0x6ae1
xorl %edi, %edi
cmpb $0x1, %cl
sete %dil
callq 0x69ce
movl $0x8, %ebx
jmp 0x6af2
movsbl %al, %esi
leaq 0x197ee(%rip), %rdi     # 0x202ba
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x52b0
jmp 0x6af2
movl %edx, %edi
shrl $0x8, %edi
movl %edx, %ecx
shrl $0x18, %edx
movb %cl, (%rsi)
movb %dil, 0x1(%rsi)
movb %al, 0x2(%rsi)
movb %dl, 0x3(%rsi)
movl $0x4, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: readbf32
uint32_t readbf32(bool be,void *p,int offset,int size)
/* read value from 32-bit bitfield */
{
  if (size>0 && offset+size<=32) {
    uint32_t mask=(1<<size)-1;

    return (be)?((read32be(p) >> (32-(offset+size))) & mask)
                :((read32le(p) >> offset) & mask);
  }
  ierror("readbf32(): Illegal arguments: offset=%d size=%d",offset,size);
  return 0;
}

// Assembly:
pushq %rbx
testl %ecx, %ecx
jle 0x6b1d
leal (%rcx,%rdx), %eax
cmpl $0x20, %eax
jg 0x6b1d
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
notl %r8d
testl %edi, %edi
je 0x6b33
movl (%rsi), %ebx
bswapl %ebx
negb %al
movl %eax, %ecx
jmp 0x6b37
leaq 0x197bf(%rip), %rdi     # 0x202e3
xorl %ebx, %ebx
movl %edx, %esi
movl %ecx, %edx
xorl %eax, %eax
callq 0x52b0
jmp 0x6b3c
movl (%rsi), %ebx
movl %edx, %ecx
shrl %cl, %ebx
andl %r8d, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: writebf32
void writebf32(bool be,void *p,int offset,int size,uint32_t d)
/* write value to 32-bit bitfield */
{
  if (size>0 && offset+size<=32) {
    uint32_t mask=(1<<size)-1;

    if (be) {
      int s = 32-(offset+size);
      write32be(p,(read32be(p) & ~(mask<<s)) | ((d & mask) << s));
    }
    else
      write32le(p,(read32le(p) & ~(mask<<offset)) | ((d & mask) << offset));
  }
  else
    ierror("writebf32(): Illegal arguments: offset=%d size=%d",offset,size);
}

// Assembly:
testl %ecx, %ecx
jle 0x6b7b
leal (%rcx,%rdx), %eax
cmpl $0x20, %eax
jg 0x6b7b
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
shll %cl, %r9d
notl %r9d
testl %edi, %edi
je 0x6b8d
negb %al
movl %r9d, %edx
movl %eax, %ecx
shll %cl, %edx
movl (%rsi), %edi
bswapl %edi
notl %edx
andl %r9d, %r8d
shll %cl, %r8d
andl %edi, %edx
orl %edx, %r8d
bswapl %r8d
jmp 0x6ba1
leaq 0x19792(%rip), %rdi     # 0x20314
movl %edx, %esi
movl %ecx, %edx
xorl %eax, %eax
jmp 0x52b0
movl %r9d, %eax
movl %edx, %ecx
shll %cl, %eax
notl %eax
andl %r9d, %r8d
shll %cl, %r8d
andl (%rsi), %eax
orl %eax, %r8d
movl %r8d, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: fwritex
void fwritex(FILE *fp,const void *buf,size_t len)
/* write a buffer of len bytes, with check for len=0 and write error */
{
  if (len) {
    if (!fwrite(buf,1,len,fp)) {
      fclose(fp);
      error(31,gvars.dest_name);  /* write error */
    }
  }
}

// Assembly:
pushq %rbx
testq %rdx, %rdx
je 0x6bc6
movq %rsi, %rax
movq %rdi, %rbx
movl $0x1, %esi
movq %rax, %rdi
movq %rbx, %rcx
callq 0x5270
testq %rax, %rax
je 0x6bc8
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x29fc1(%rip), %rax     # 0x30b98
movq 0x48(%rax), %rsi
movl $0x1f, %edi
xorl %eax, %eax
popq %rbx
jmp 0x6f14
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: fwrite32be
void fwrite32be(FILE *fp,uint32_t w)
/* write a big endian 32 bit word */
{
  uint8_t be[4];

  be[0] = (w>>24) & 0xff;
  be[1] = (w>>16) & 0xff;
  be[2] = (w>>8) & 0xff;
  be[3] = w & 0xff;
  if (!fwrite(be,4,sizeof(uint8_t),fp)) {
    fclose(fp);
    error(31,gvars.dest_name);  /* write error */
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
bswapl %esi
leaq 0xc(%rsp), %rdi
movl %esi, (%rdi)
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x5270
testq %rax, %rax
je 0x6c16
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x29f73(%rip), %rax     # 0x30b98
movq 0x48(%rax), %rsi
movl $0x1f, %edi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6f14
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: fwrite16be
void fwrite16be(FILE *fp,uint16_t w)
/* write a big endian 16 bit word */
{
  uint8_t be[2];

  be[0] = (w>>8) & 0xff;
  be[1] = w & 0xff;
  if (!fwrite(be,2,sizeof(uint8_t),fp)) {
    fclose(fp);
    error(31,gvars.dest_name);  /* write error */
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
rolw $0x8, %si
leaq 0xe(%rsp), %rdi
movw %si, (%rdi)
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x5270
testq %rax, %rax
je 0x6c6b
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x29f1e(%rip), %rax     # 0x30b98
movq 0x48(%rax), %rsi
movl $0x1f, %edi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6f14
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: fwrite_align
void fwrite_align(FILE *fp,uint32_t a,uint32_t n)
/* writes as many zero bytes as required for alignment a (a bits */
/* must be zero) with current file offset n */
{
  static uint8_t alignment_bytes[MAX_FWALIGN];

  a = 1<<a;
  if ((n = (a-(n&(a-1))&(a-1))) > MAX_FWALIGN)
    ierror("fwrite_align(): Alignment > %d required",MAX_FWALIGN);
  fwritex(fp,alignment_bytes,n);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ecx
movq %rdi, %rbx
movl $0x1, %r14d
shll %cl, %r14d
leal -0x1(%r14), %eax
andl %eax, %edx
subl %edx, %r14d
andl %eax, %r14d
cmpl $0x2001, %r14d          # imm = 0x2001
jb 0x6d1a
leaq 0x19638(%rip), %rdi     # 0x20346
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0x52b0
movl %r14d, %edx
leaq 0x2a0cc(%rip), %rsi     # 0x30df0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6ba5
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: fwritegap
void fwritegap(FILE *f,long bytes)
{
  uint8_t buf[GAPBUFSIZE];

  memset(buf,0,GAPBUFSIZE);
  do
    fwritex(f,buf,bytes>GAPBUFSIZE?GAPBUFSIZE:bytes);
  while ((bytes-=GAPBUFSIZE) > 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x400, %r12d           # imm = 0x400
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
xorl %esi, %esi
callq 0x5120
cmpq %r12, %r14
movl $0x400, %edx            # imm = 0x400
cmovlq %r14, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ba5
leaq -0x400(%r14), %rax
cmpq %r12, %r14
movq %rax, %r14
jg 0x6d5f
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: elf_hash
unsigned long elf_hash(const unsigned char *name)
/* calculate a hash code as used in ELF objects */
{
  unsigned long h=0,g;

  while (*name) {
    h = (h << 4) + *name++;
    if (g = h & 0xf0000000)
      h ^= g >> 24;
    h &= ~g;
  }
  return h;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x6dc8
incq %rdi
xorl %eax, %eax
shlq $0x4, %rax
movzbl %cl, %ecx
addq %rax, %rcx
movl %ecx, %eax
andl $0xf0000000, %eax       # imm = 0xF0000000
movl %eax, %edx
shrl $0x18, %edx
xorq %rcx, %rdx
notq %rax
andq %rdx, %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x6d9f
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: shiftcnt
int shiftcnt(uint32_t x)
/* returns number of 0-bits before the first 1-bit - something like */
/* an integer-log2() function - returns 0 on x=0 */
{
  int i;

  if (x == 0)
    return 0;
  for (i=0; i<32; i++) {
    if (x & 1)
      break;
    x >>= 1;
  }
  return i;
}

// Assembly:
testl %edi, %edi
sete %cl
xorl %eax, %eax
movl %edi, %edx
orb %cl, %dl
testb $0x1, %dl
jne 0x6e26
xorl %eax, %eax
movl %eax, %ecx
leal 0x1(%rcx), %eax
cmpl $0x1e, %ecx
ja 0x6e26
movl %edi, %ecx
shrl %ecx
andl $0x2, %edi
movl %ecx, %edi
je 0x6e11
retq
// File: /workspace/github_c_makefile_star2_O3/deplinenoise[P]vlink/support.c
// Function: lshiftcnt
int lshiftcnt(lword x)
/* shiftcnt() of an lword */
{
  int i,n=sizeof(lword)<<3;

  if (x == 0)
    return 0;
  for (i=0; i<n; i++) {
    if (x & 1)
      break;
    x >>= 1;
  }
  return i;
}

// Assembly:
testq %rdi, %rdi
sete %cl
xorl %eax, %eax
movl %edi, %edx
orb %cl, %dl
testb $0x1, %dl
jne 0x6e52
xorl %eax, %eax
movl %eax, %ecx
leal 0x1(%rcx), %eax
cmpl $0x3e, %ecx
ja 0x6e52
movq %rdi, %rcx
sarq %rcx
andl $0x2, %edi
movq %rcx, %rdi
je 0x6e3a
retq