LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x40(%rsp), %xmm8
movsd 0x48(%rsp), %xmm9
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 0x3180(%rip), %xmm0     # 0x1ba88
jne 0x18910
jnp 0x189f5
movapd %xmm2, %xmm1
addsd %xmm2, %xmm1
subsd %xmm1, %xmm10
movsd 0x320b(%rip), %xmm4     # 0x1bb30
mulsd %xmm5, %xmm4
mulsd %xmm2, %xmm4
movapd %xmm10, %xmm1
mulsd %xmm10, %xmm1
addsd %xmm4, %xmm1
ucomisd %xmm1, %xmm3
ja 0x189f5
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jb 0x18955
sqrtsd %xmm1, %xmm1
jmp 0x18980
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 0x189a5
movsd 0x3109(%rip), %xmm2     # 0x1baa8
ucomisd %xmm0, %xmm2
jae 0x189f5
xorpd 0x742(%rip), %xmm10     # 0x190f0
subsd %xmm1, %xmm10
divsd %xmm5, %xmm10
movapd %xmm10, %xmm1
cmplesd 0x30e2(%rip), %xmm1     # 0x1baa8
movapd %xmm1, %xmm0
andpd %xmm10, %xmm0
movsd 0x30b1(%rip), %xmm2     # 0x1ba88
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_O2/yui0[P]img2vec/./potracelib.h
// Function: bm_base
static inline potrace_word *bm_base(const potrace_bitmap_t *bm) {
  int dy = bm->dy;
  if (dy >= 0 || bm->h == 0) {
    return bm->map;
  } else {
    return bm_scanline(bm, bm->h - 1);
  }  
}

// Assembly:
movslq 0x8(%rdi), %rcx
testq %rcx, %rcx
js 0x18d19
movq 0x10(%rdi), %rax
retq
movslq 0x4(%rdi), %rax
testq %rax, %rax
je 0x18d14
decq %rax
imulq %rcx, %rax
shlq $0x3, %rax
addq 0x10(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/yui0[P]img2vec/./potracelib.h
// Function: getsize
static inline ptrdiff_t getsize(int dy, int h) {
  ptrdiff_t size;
  if (dy < 0) {
    dy = -dy;
  }
  
  size = (ptrdiff_t)dy * (ptrdiff_t)h * (ptrdiff_t)BM_WORDSIZE;
  /* check for overflow error */
  if (size < 0 || (h != 0 && dy != 0 && size / h / dy != BM_WORDSIZE)) {
    return -1;
  }
  return size;
}

// Assembly:
movl %edi, %r9d
negl %r9d
cmovsl %edi, %r9d
movslq %esi, %r10
movq %r9, %r8
imulq %r10, %r8
pushq $-0x1
popq %rcx
testq %r8, %r8
js 0x18d76
shlq $0x3, %r8
testl %esi, %esi
sete %al
testl %edi, %edi
sete %dl
orb %al, %dl
jne 0x18d73
movq %r8, %rax
cqto
idivq %r10
cqto
idivq %r9
cmpq $0x8, %rax
jne 0x18d76
movq %r8, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x594f(%rip), %rsi      # 0x7d30
leaq 0x8(%rsp), %rdi
movl $0xa0, %edx
callq 0x2170
cmpl $0x2, %ebp
jne 0x242d
movq 0x8(%rbx), %rdi
cmpb $0x2d, (%rdi)
jne 0x240a
cmpb $0x68, 0x1(%rdi)
jne 0x240a
cmpb $0x0, 0x2(%rdi)
je 0x242d
callq 0x2240
leaq 0x35(%rip), %rdx        # 0x244b
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x3361
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
jmp 0x2441
movq (%rbx), %rsi
leaq 0x2bcd(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x20b0
pushq $0x1
popq %rax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kilobyte[P]colormatch/16x16.c
// Function: main
int main()
{
    printf("     ");
    for (int x=0; x<16; ++x)
    {
        printf("\e[48;2;");
        pc(x);
        printf(";%d;4m%3d \e[0m", neg16(x), x);
    }
    printf("\n");

    for (int y=0; y<16; ++y)
    {
        printf("\e[48;2;");
        pc(y);
        printf(";%dm%3d \e[0m ", neg16(y), y);

        for (int x=0; x<16; ++x)
        {
            printf("\e[0;38;2;");
            pc(x);
            printf(";48;2;");
            pc(y);
            printf("m%4d\e[0m", (color_diff(col256_to_rgb(x), col256_to_rgb(y))
                          +16777216/2)/16777216);
        }

        int v = col256_to_rgb(y);
        printf(" %02x%02x%02x\n", (v>>16)&255, (v>>8)&255, v&255);
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe36(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1060
leaq 0xe2e(%rip), %rbx       # 0x200a
leaq 0xe2f(%rip), %r14       # 0x2012
xorl %ebp, %ebp
cmpl $0x10, %ebp
je 0x1217
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1060
movl %ebp, %edi
callq 0x1319
cmpl $0x9, %ebp
pushq $0x1e
popq %rsi
pushq $0x61
popq %rax
cmovbl %eax, %esi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1060
incl %ebp
jmp 0x11e5
pushq $0xa
popq %rdi
callq 0x1030
leaq 0xe13(%rip), %r13       # 0x2039
movl $0x1000000, %r12d       # imm = 0x1000000
leaq 0xe0d(%rip), %rbp       # 0x2040
xorl %ebx, %ebx
cmpl $0x10, %ebx
je 0x1308
xorl %r14d, %r14d
leaq 0xdc2(%rip), %rdi       # 0x200a
xorl %eax, %eax
callq 0x1060
movl %ebx, %edi
callq 0x1319
cmpl $0x9, %ebx
pushq $0x1e
popq %rsi
pushq $0x61
popq %rax
cmovbl %eax, %esi
leaq 0xdb8(%rip), %rdi       # 0x2021
movl %ebx, %edx
xorl %eax, %eax
callq 0x1060
cmpl $0x10, %r14d
je 0x12d5
leaq 0xdb0(%rip), %rdi       # 0x202f
xorl %eax, %eax
callq 0x1060
movl %r14d, %edi
callq 0x1319
movq %r13, %rdi
xorl %eax, %eax
callq 0x1060
movl %ebx, %edi
callq 0x1319
movl %r14d, %edi
callq 0x1bfc
movl %eax, %r15d
movl %ebx, %edi
callq 0x1bfc
movl %r15d, %edi
movl %eax, %esi
callq 0x1bb4
addl $0x800000, %eax         # imm = 0x800000
cltd
idivl %r12d
movq %rbp, %rdi
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
incl %r14d
jmp 0x1272
movl %ebx, %edi
callq 0x1bfc
movl %eax, %esi
shrl $0x10, %esi
movl $0xff, %ecx
andl %ecx, %esi
movl %eax, %edx
shrl $0x8, %edx
andl %ecx, %edx
andl %ecx, %eax
leaq 0xd51(%rip), %rdi       # 0x2049
movl %eax, %ecx
xorl %eax, %eax
callq 0x1060
incl %ebx
jmp 0x1235
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/X1319RAY[P]fileIO/fgets.c
// Function: main
int main(int argc, char* argv[]){
	
	// コマンドライン引数のチェック
	if(argc != 2){
		fprintf(stderr, "引数の数が間違っています．\n");
		fprintf(stderr, "./fgets input.txt\n");
		return 1;
	}
	
	// C言語のファイル入力のための準備
	FILE* fp; // FILE型構造体
	// 読み込みモードでファイルを開く
	fp = fopen(argv[1], "r"); // 失敗するとNULLを返す
	// ファイルを開くのに失敗したときの処理
	if(fp == NULL){
		fprintf(stderr, "Error: file not opened.\n");
		return 1;
	}
	
	// fgets()で1行ずつ読み込む
	char tmp[BUFSIZE]; // fgets()はchar型配列に格納するのでchar型配列を用意
	int num = 0;
	int sum = 0;
	while(fgets(tmp, BUFSIZE, fp) != NULL){
		// ここでtmpを煮るなり焼くなりする
		printf("%s", tmp); // そのまま出力
		// tmpの中身を確認
		for(int i = 0; i < BUFSIZE; i++){
			// 数字ならnumに数として格納
			if(isdigit(tmp[i])){
				num = num * 10; // 位を1つ大きくする
				num += tmp[i] - '0'; // 一の位に値を入れる
			}
			else{
				// 数字が終わった直後ならnumがsumに加算される
				// その後numを0にしているので直後以外はsumに0を加算
				sum += num;
				num = 0;
			}
			if(tmp[i] == '\n') break;
		}
	}
	
	printf("\nsum: %d\n", sum);
	
	// ファイルを閉じる
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
cmpl $0x2, %edi
jne 0x128f
movq 0x8(%rsi), %rdi
leaq 0xe8c(%rip), %rsi       # 0x2040
callq 0x1060
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x12c0
xorl %r14d, %r14d
xorl %r12d, %r12d
leaq -0x430(%rbp), %rbx
movq %rbx, %rdi
movl $0x400, %esi            # imm = 0x400
movq -0x30(%rbp), %rdx
callq 0x1050
testq %rax, %rax
je 0x125d
leaq 0xe6b(%rip), %rdi       # 0x205b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1040
xorl %ebx, %ebx
movl %r14d, %r15d
movl %r12d, %r13d
cmpq $0x400, %rbx            # imm = 0x400
je 0x1252
callq 0x1080
movq (%rax), %rax
movsbl -0x430(%rbp,%rbx), %ecx
movslq %ecx, %rcx
imull $0xa, %r15d, %edx
testb $0x8, 0x1(%rax,%rcx,2)
leal -0x30(%rdx,%rcx), %r14d
movl $0x0, %eax
cmovel %eax, %r14d
cmovnel %eax, %r15d
movl %r15d, %r12d
addl %r13d, %r12d
incq %rbx
movl %r14d, %r15d
movl %r12d, %r13d
cmpl $0xa, %ecx
jne 0x1202
jmp 0x11cc
movl %r15d, %r14d
movl %r13d, %r12d
jmp 0x11cc
leaq 0xdfa(%rip), %rdi       # 0x205e
xorl %r14d, %r14d
movl %r12d, %esi
xorl %eax, %eax
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x1030
movl %r14d, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d62(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0xd64(%rip), %rdi       # 0x2004
pushq $0x28
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1070
movq (%r14), %rcx
leaq 0xd75(%rip), %rdi       # 0x202d
pushq $0x12
popq %rsi
movq %rbx, %rdx
jmp 0x12d7
movq 0x2d31(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xd71(%rip), %rdi       # 0x2042
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x1070
pushq $0x1
popq %r14
jmp 0x127a
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
callq 0x1090
leaq 0x28(%rax), %rcx
movq %rcx, (%rax)
movq %r14, 0x10(%rax)
testq %rbx, %rbx
leaq -0x4d(%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_O2/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
xorl %r12d, %r12d
cmpq %r15, %r12
je 0x12a1
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax,%r12,8)
je 0x129c
movq (%rbx), %r14
movq %r12, %r13
shlq $0x4, %r13
movq (%r14,%r13), %rdi
callq 0x1030
movq 0x8(%r14,%r13), %r14
testq %r14, %r14
je 0x129c
movq (%r14), %rdi
callq 0x1030
movq 0x8(%r14), %r13
movq %r14, %rdi
callq 0x1030
movq %r13, %r14
jmp 0x127e
incq %r12
jmp 0x1256
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x13a9
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 0x1377
cmpq $0x0, 0x8(%rdi)
jne 0x13c6
movq %r14, (%rdi)
andq $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 0x13e5
testq %rax, %rax
je 0x1398
movq %rax, %r15
movq (%rax), %rdi
callq 0x1030
movq %r14, (%r15)
jmp 0x1368
pushq $0x10
popq %rdi
callq 0x10c0
movq %rax, %rdi
movq %rax, 0x8(%rbp)
jmp 0x135c
leaq 0xc54(%rip), %rdi       # 0x2004
leaq 0xc60(%rip), %rsi       # 0x2017
leaq 0xc69(%rip), %rcx       # 0x2027
pushq $0x6c
popq %rdx
callq 0x1080
leaq 0xca7(%rip), %rdi       # 0x2074
leaq 0xc43(%rip), %rsi       # 0x2017
leaq 0xc4c(%rip), %rcx       # 0x2027
movl $0x8d, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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 0x1413
cmpq %r14, 0x8(%rax)
jne 0x1413
movq (%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10d0
testl %eax, %eax
je 0x141e
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x13f3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14c8
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 0x14bf
shlq $0x4, %rdx
addq (%r15), %rdx
movq %rdx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x13e5
testq %rax, %rax
je 0x14bd
movq (%rax), %rcx
jmp 0x14bf
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb35(%rip), %rdi       # 0x2004
leaq 0xb41(%rip), %rsi       # 0x2017
leaq 0xbaa(%rip), %rcx       # 0x2087
movl $0xd0, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl $0x7a120, %edi          # imm = 0x7A120
xorl %esi, %esi
callq 0x11f2
movq %rax, %rbx
movq %rax, %rdi
callq 0x10a0
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x1050
leaq 0xb4c(%rip), %rsi       # 0x20bd
movq %rbx, %rdi
callq 0x14e7
movq %rax, %r14
movq %rsp, %r12
movl %ebp, %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
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
leaq 0xb53(%rip), %rdi       # 0x2122
movq %rax, %rsi
xorl %eax, %eax
callq 0x1070
testq %r14, %r14
je 0x15e4
movq 0x10(%r14), %rdi
jmp 0x15eb
leaq 0xb41(%rip), %rdi       # 0x212c
callq 0x1040
movq %rbx, %rdi
callq 0x1243
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/wjmelements[P]evm/tst/keccak.c
// Function: test_empty
void test_empty() {
    uint8_t result[32];
    int success;

    success = sha3_256(result, 32, result, 0);
    assert(success == 0);
    assertEqual32(expectedEmptySha3, result);

    success = keccak_256(result, 32, result, 0);
    assert(success == 0);
    assertEqual32(expectedEmptyKeccak, result);
}

// Assembly:
subq $0x28, %rsp
pushq $0x20
popq %rsi
movq %rsp, %rdi
movq %rdi, %rdx
xorl %ecx, %ecx
callq 0x122c
testl %eax, %eax
jne 0x11b9
leaq 0xeb5(%rip), %rdi       # 0x2030
movq %rsp, %rsi
pushq $0x20
popq %rdx
callq 0x1050
testl %eax, %eax
jne 0x11d2
pushq $0x20
popq %rsi
movq %rsp, %rdi
movq %rdi, %rdx
xorl %ecx, %ecx
callq 0x130b
testl %eax, %eax
jne 0x11eb
leaq 0xe6b(%rip), %rdi       # 0x2010
movq %rsp, %rsi
pushq $0x20
popq %rdx
callq 0x1050
testl %eax, %eax
jne 0x1204
addq $0x28, %rsp
retq
leaq 0xe90(%rip), %rdi       # 0x2050
leaq 0xe96(%rip), %rsi       # 0x205d
leaq 0xe9c(%rip), %rcx       # 0x206a
pushq $0x1b
jmp 0x121b
leaq 0xea3(%rip), %rdi       # 0x207c
leaq 0xe7d(%rip), %rsi       # 0x205d
leaq 0xe83(%rip), %rcx       # 0x206a
pushq $0x1c
jmp 0x121b
leaq 0xe5e(%rip), %rdi       # 0x2050
leaq 0xe64(%rip), %rsi       # 0x205d
leaq 0xe6a(%rip), %rcx       # 0x206a
pushq $0x1f
jmp 0x121b
leaq 0xe9c(%rip), %rdi       # 0x20a7
leaq 0xe4b(%rip), %rsi       # 0x205d
leaq 0xe51(%rip), %rcx       # 0x206a
pushq $0x20
popq %rdx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x31db(%rip), %xmm1     # 0x6094
movss %xmm1, 0x18(%rdi)
divss 0xc(%rdi), %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x1c(%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x2ee3
pushq $0x1
popq %rsi
callq 0x21f0
movl 0x1c(%rbx), %eax
movss 0x18(%rbx), %xmm1
cvtsi2ss %eax, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
andl $0x0, 0x50(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2f2f
pushq $0x1
popq %rsi
callq 0x21f0
movl 0x1c(%rbx), %eax
cvtsi2ss %eax, %xmm0
addss 0x18(%rbx), %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
andl $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x312c(%rip), %xmm1     # 0x6094
movss %xmm1, 0x18(%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x2f83
pushq $0x1
popq %rsi
callq 0x21f0
movss 0x18(%rbx), %xmm1
cvtsi2ssl 0x1c(%rbx), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %edi
movl %edi, 0x58(%rbx)
callq 0x2030
movq %rax, 0x60(%rbx)
andl $0x0, 0x50(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2da4
leaq 0x4449(%rip), %rax      # 0x8ce0
movq %rax, (%rbx)
movsd 0x180e(%rip), %xmm0     # 0x60b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x4960
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e40
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2da4
leaq 0x43e6(%rip), %rax      # 0x8ce0
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 0x4960
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e40
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2fda
movss 0x8(%rbx), %xmm2
movss 0x10(%rbx), %xmm0
divss %xmm0, %xmm2
movss %xmm2, 0x8(%rsp)
movss 0x170b(%rip), %xmm1     # 0x6094
mulss %xmm2, %xmm1
movss %xmm1, 0xc(%rsp)
movss %xmm1, 0x18(%rbx)
divss 0xc(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x1727(%rip), %xmm0     # 0x60d0
callq 0x2340
cvtss2sd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x1710(%rip), %xmm0     # 0x60d0
callq 0x2340
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)
andq $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_O2/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 0x2da4
leaq 0x3cbd(%rip), %rax      # 0x8d28
movq %rax, (%rbx)
movsd 0x103a(%rip), %xmm0     # 0x60b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x5134
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e40
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2da4
leaq 0x3c5a(%rip), %rax      # 0x8d28
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 0x5134
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e40
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2fda
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 0xf65(%rip), %xmm0      # 0x60d0
callq 0x2340
cvtss2sd 0xc(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0xf4e(%rip), %xmm0      # 0x60d0
callq 0x2340
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)
andq $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_O2/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 0x2da4
leaq 0x36d1(%rip), %rax      # 0x8d70
movq %rax, (%rbx)
movsd 0xa06(%rip), %xmm0      # 0x60b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x5768
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2e40
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_c_makefile_star2_O2/DrYerzinia[P]C_DigiMode/src/psk31/psk31_wpdd.cpp
// Function: psk31_wpdd::init()
void psk31_wpdd::init(){

	initVaricode();

	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 0x2fda
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 0x931(%rip), %xmm0      # 0x60d0
callq 0x2340
cvtss2sd 0xc(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x91a(%rip), %xmm0      # 0x60d0
callq 0x2340
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)
andq $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_O2/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 0x17014
movslq 0x18(%r14), %r15
incq %rdi
callq 0x41d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
je 0x17035
movq 0x38(%r14), %rcx
leaq 0x5e665(%rip), %rsi     # 0x75664
leaq 0x5e695(%rip), %rdx     # 0x7569b
movl %ebp, %edi
movq %rbx, %r8
xorl %eax, %eax
callq 0xc19e
jmp 0x17032
movq 0x38(%r14), %r9
leaq 0x5e645(%rip), %rsi     # 0x75664
leaq 0x5e64e(%rip), %rdx     # 0x75674
movl %ebp, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xc19e
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/main.c
// Function: get_arg
static char *get_arg(int argc, char *argv[],int *i)
{
  if ((*i+1)<argc && *argv[*i+1]!='-')
    return argv[++*i];
  error(34,argv[*i]);  /* option requires argument */
  return NULL;  /* not reached */
}

// Assembly:
pushq %rbx
movslq (%rdx), %rax
leal 0x1(%rax), %ecx
cmpl %edi, %ecx
jge 0x6255
movq 0x8(%rsi,%rax,8), %rbx
cmpb $0x2d, (%rbx)
jne 0x6267
movq (%rsi,%rax,8), %rsi
xorl %ebx, %ebx
pushq $0x22
popq %rdi
xorl %eax, %eax
callq 0x6c19
jmp 0x6269
movl %ecx, (%rdx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6290
addq $0x2, %r15
movq %r15, %r14
jmp 0x62d2
movq %rdx, %rbx
leal 0x1(%r12), %ecx
movl %ecx, (%rdx)
cmpl %edi, %ecx
jge 0x62bd
movq 0x8(%rsi,%rax,8), %r14
cmpb $0x2d, (%r14)
jne 0x62d2
callq 0x52a0
movq (%rax), %rax
movzbl 0x1(%r14), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x62d2
movl %r12d, (%rbx)
movsbl 0x1(%r15), %esi
xorl %r14d, %r14d
pushq $0x5
popq %rdi
xorl %eax, %eax
callq 0x6c19
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17f83(%rip), %rsi     # 0x1e276
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0x6323
leaq 0x17f7a(%rip), %rsi     # 0x1e280
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0x6329
xorl %ebp, %ebp
pushq $0x2
popq %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6c19
jmp 0x632d
movw $0x1, %bp
jmp 0x632d
movw $0x2, %bp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6360
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x6c19
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5210
movq %rax, %rbx
testq %rax, %rax
jne 0x6385
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x6c19
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17e2d(%rip), %rsi     # 0x1e295
callq 0x5230
testq %rax, %rax
je 0x6521
movq %rax, %r14
movq %rax, %rdi
callq 0x5190
testq %rax, %rax
js 0x64bb
movq %rax, %r12
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x5200
testl %eax, %eax
js 0x64bb
movq %r14, %rdi
callq 0x5190
testq %rax, %rax
js 0x64bb
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x5200
testl %eax, %eax
jns 0x64d3
movq %r14, %rdi
callq 0x50c0
xorl %r15d, %r15d
pushq $0x5
popq %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6c19
leaq 0x9(%r15), %rdi
callq 0x6340
movq %rax, %r12
movq %r15, (%rax)
movb $0x0, 0x8(%rax,%r15)
addq $0x8, %r12
pushq $0x1
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x50b0
cmpq %r15, %rax
je 0x6517
movq %r14, %rdi
callq 0x50c0
pushq $0x7
popq %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6c19
movq %r14, %rdi
callq 0x50c0
jmp 0x6524
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x657f
movzbl -0x1(%rbx,%rsi), %edi
addq %rax, %rcx
cmpl $0x3a, %edi
je 0x6578
movq %rdx, %rsi
cmpl $0x2f, %edi
jne 0x655d
sarq $0x20, %rcx
addq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x65d2
leal -0x1(%rdx), %ecx
pushq $0x1
popq %rdi
shlq %cl, %rdi
movq %rdi, %r8
pushq $-0x1
popq %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 0x65e5
leaq 0x17cbf(%rip), %rdi     # 0x1e298
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x6b2c
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6698
movl %edx, %ecx
shrl $0x18, %ecx
movl %eax, %edi
movl %edx, %eax
shrl $0x8, %eax
jmp 0x66a2
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_O2/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 0x28abb(%rip), %rcx     # 0x2f190
movq (%rcx,%rax,8), %rcx
movb 0xaa(%rcx), %al
xorl %edi, %edi
cmpb $0x1, %al
sete %dil
movzbl 0xab(%rcx), %ecx
cmpl $0x40, %ecx
je 0x671c
cmpl $0x20, %ecx
je 0x6713
cmpl $0x10, %ecx
jne 0x6726
cmpb $0x1, %al
movzbl %dh, %eax
movl %eax, %ecx
cmovel %edx, %ecx
cmovel %eax, %edx
movb %dl, (%rsi)
movb %cl, 0x1(%rsi)
pushq $0x2
jmp 0x6723
callq 0x6681
pushq $0x4
jmp 0x6723
callq 0x66af
pushq $0x8
popq %rbx
jmp 0x6739
movsbl %cl, %esi
leaq 0x17b8a(%rip), %rdi     # 0x1e2ba
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x6b2c
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testl %ecx, %ecx
jle 0x676c
leal (%rcx,%rdx), %ebp
cmpl $0x20, %ebp
jg 0x676c
pushq $-0x1
popq %r14
shll %cl, %r14d
notl %r14d
testl %edi, %edi
je 0x6782
movq %rsi, %rdi
callq 0x6607
movl %eax, %ebx
negb %bpl
movl %ebp, %ecx
jmp 0x6786
leaq 0x17b70(%rip), %rdi     # 0x1e2e3
xorl %ebx, %ebx
movl %edx, %esi
movl %ecx, %edx
xorl %eax, %eax
callq 0x6b2c
jmp 0x678b
movl (%rsi), %ebx
movl %edx, %ecx
shrl %cl, %ebx
andl %r14d, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %ecx, %ecx
jle 0x67da
leal (%rcx,%rdx), %ebp
cmpl $0x20, %ebp
jg 0x67da
movl %r8d, %ebx
movq %rsi, %r14
pushq $-0x1
popq %r15
shll %cl, %r15d
notl %r15d
testl %edi, %edi
je 0x67f6
movq %r14, %rdi
callq 0x6607
negb %bpl
movl %r15d, %edx
movl %ebp, %ecx
shll %cl, %edx
notl %edx
andl %r15d, %ebx
shll %cl, %ebx
andl %eax, %edx
orl %edx, %ebx
bswapl %ebx
jmp 0x6809
leaq 0x17b33(%rip), %rdi     # 0x1e314
movl %edx, %esi
movl %ecx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x6b2c
movl %r15d, %eax
movl %edx, %ecx
shll %cl, %eax
notl %eax
andl %r15d, %ebx
shll %cl, %ebx
andl (%r14), %eax
orl %eax, %ebx
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6836
movq %rdi, %rbx
pushq $0x1
popq %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x5280
testq %rax, %rax
je 0x6838
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x2a741(%rip), %rax     # 0x30f88
movq 0x48(%rax), %rsi
pushq $0x1f
popq %rdi
xorl %eax, %eax
popq %rbx
jmp 0x6c19
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x5280
testq %rax, %rax
je 0x6880
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x2a6f9(%rip), %rax     # 0x30f88
movq 0x48(%rax), %rsi
pushq $0x1f
popq %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6c19
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x5280
testq %rax, %rax
je 0x68cf
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x2a6aa(%rip), %rax     # 0x30f88
movq 0x48(%rax), %rsi
pushq $0x1f
popq %rdi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6c19
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r14
shll %cl, %r14d
leal -0x1(%r14), %eax
andl %eax, %edx
subl %edx, %r14d
andl %eax, %r14d
cmpl $0x2001, %r14d          # imm = 0x2001
jb 0x6974
leaq 0x179de(%rip), %rdi     # 0x1e346
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0x6b2c
movl %r14d, %edx
leaq 0x2a862(%rip), %rsi     # 0x311e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6817
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movzbl (%rdi), %ecx
testq %rcx, %rcx
je 0x6a1d
shlq $0x4, %rax
incq %rdi
addq %rcx, %rax
movl %eax, %ecx
andl $0xf0000000, %ecx       # imm = 0xF0000000
movl %ecx, %edx
shrl $0x18, %edx
xorq %rax, %rdx
notq %rcx
andq %rdx, %rcx
movq %rcx, %rax
jmp 0x69f0
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/support.c
// Function: memset16
void memset16(struct GlobalVars *gv,void *start,uint16_t fill,long n)
{
  if (n > 0) {
    uint8_t f[2];
    uint8_t *p;
    int i;

    write16(fff[gv->dest_format]->endianess==_BIG_ENDIAN_,f,fill);
    for (p=start,i=((unsigned long)start)&1; n; n--,i^=1)
      *p++ = f[i];
  }
}

// Assembly:
testq %rcx, %rcx
jle 0x6ad7
movzbl 0x50(%rdi), %eax
leaq 0x286fc(%rip), %rdi     # 0x2f190
movq (%rdi,%rax,8), %rax
movzwl %dx, %edx
movl %edx, %edi
shrl $0x8, %edi
cmpb $0x1, 0xaa(%rax)
movl %edi, %eax
cmovel %edx, %eax
cmovnel %edx, %edi
movb %dil, -0x2(%rsp)
movb %al, -0x1(%rsp)
movl %esi, %eax
andl $0x1, %eax
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x6ad7
movl %eax, %edi
movb -0x2(%rsp,%rdi), %dil
movb %dil, (%rsi,%rdx)
xorl $0x1, %eax
incq %rdx
jmp 0x6abf
retq
// File: /workspace/github_c_makefile_star2_O2/deplinenoise[P]vlink/support.c
// Function: add_symnames
void add_symnames(struct SymNames **snlist,const char *name)
/* add a new name to a SymNames list */
{
  struct SymNames *new = alloc(sizeof(struct SymNames));
  struct SymNames *sn;

  new->next = NULL;
  new->name = name;
  if (sn = *snlist) {
    while (sn->next)
      sn = sn->next;
    sn->next = new;
  }
  else
    *snlist = new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x6340
andq $0x0, (%rax)
movq %r14, 0x8(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x6b1e
movq %rcx, %rbx
movq (%rcx), %rcx
jmp 0x6b11
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)