LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/yurrriq[P]knrc/src/longestline.c
// Function: main
int main()
{
    int len, max;
    char line[MAXLINE], longest[MAXLINE];

    max = 0;
    while ((len = get_line(line, MAXLINE)) > 0)
        if (len > max) {
            max = len;
            copy(longest, line);
        }

    if (max > 0) {
        printf("The longest line had %d characters:\n%s", max, longest);
        if (max >= MAXLINE && longest[MAXLINE - 1] != '\n')
            fputs("...\n", stdout);
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
leaq 0x50(%rsp), %rdi
movl $0x50, %esi
callq 0x1200
xorl %ebx, %ebx
testl %eax, %eax
jle 0x11a7
leaq 0x50(%rsp), %r14
cmpl %ebx, %eax
jle 0x1196
xorl %ecx, %ecx
movb 0x50(%rsp,%rcx), %dl
movb %dl, (%rsp,%rcx)
incq %rcx
testb %dl, %dl
jne 0x1186
movl %eax, %ebx
movq %r14, %rdi
movl $0x50, %esi
callq 0x1200
testl %eax, %eax
jg 0x1180
testl %ebx, %ebx
jle 0x11e0
leaq 0xe52(%rip), %rdi       # 0x2004
movq %rsp, %rdx
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
cmpl $0x50, %ebx
jl 0x11e0
cmpb $0xa, 0x4f(%rsp)
je 0x11e0
movq 0x2e0f(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xe50(%rip), %rdi       # 0x202b
callq 0x1040
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/yurrriq[P]knrc/src/get_line.c
// Function: get_line
int get_line(char s[], int lim)
{
    int c = EOF, i;

    for (i = 0; i < lim - 1 && (c = getchar()) != EOF; ++i) {
        s[i] = c;
        if (c == '\n') {
            ++i;
            break;
        }
    }

    s[i] = '\0';

    if (c == '\n')
        return i;

    while ((c = getchar()) != EOF) {
        ++i;
        if (c == '\n')
            break;
    }

    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %eax, %eax
movl $0x0, %ebx
cmpl $0x2, %esi
jl 0x1248
movl %esi, %ebp
decl %ebp
movl %ebp, %r15d
xorl %ebx, %ebx
callq 0x1050
cmpl $-0x1, %eax
je 0x1240
movb %al, (%r14,%rbx)
cmpl $0xa, %eax
je 0x1244
incq %rbx
cmpq %rbx, %r15
jne 0x121f
xorl %eax, %eax
movl %ebp, %ebx
jmp 0x1248
xorl %eax, %eax
jmp 0x1248
incl %ebx
movb $0x1, %al
movslq %ebx, %rcx
movb $0x0, (%r14,%rcx)
testb %al, %al
jne 0x1265
callq 0x1050
cmpl $-0x1, %eax
je 0x1265
incl %ebx
cmpl $0xa, %eax
jne 0x1254
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1307
movq 0x8(%rsi), %rdi
leaq 0xe1c(%rip), %rsi       # 0x2040
callq 0x1060
testq %rax, %rax
je 0x130e
movq %rax, %rbx
leaq -0x430(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdx
callq 0x1050
movl $0x0, %r13d
testq %rax, %rax
je 0x12da
xorl %r14d, %r14d
leaq -0x430(%rbp), %r12
xorl %r13d, %r13d
xorl %r15d, %r15d
leaq 0xdec(%rip), %rdi       # 0x205b
movq %r12, %rsi
xorl %eax, %eax
callq 0x1040
callq 0x1080
movq (%rax), %rax
xorl %ecx, %ecx
movl %r13d, %edx
movl %r15d, %esi
movsbl -0x430(%rbp,%rcx), %edi
movslq %edi, %rdi
testb $0x8, 0x1(%rax,%rdi,2)
leal (%rsi,%rsi,4), %r8d
cmovnel %r14d, %esi
movl %esi, %r13d
leal -0x30(%rdi,%r8,2), %r15d
cmovel %r14d, %r15d
addl %edx, %r13d
cmpl $0xa, %edi
je 0x12c5
leaq 0x1(%rcx), %rdx
cmpq $0x3ff, %rcx            # imm = 0x3FF
movq %rdx, %rcx
jb 0x1283
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x1050
testq %rax, %rax
jne 0x1268
leaq 0xd7d(%rip), %rdi       # 0x205e
movl %r13d, %esi
xorl %eax, %eax
callq 0x1040
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10a0
jmp 0x1313
callq 0x10df
movl $0x1, %eax
jmp 0x12f5
// File: /workspace/github_c_makefile_star2_O1/ammarfaizi2[P]hashtable/src/hashtable.c
// Function: default_ht_hash_f
size_t
default_ht_hash_f(const void *key, size_t len)
{
  size_t              ret   = 0;
  const unsigned char *ckey = (const unsigned char *)key;

  for (size_t i = 0; i < len; i++) {
    ret += (size_t)ckey[i];
  }

  return ret;
}

// Assembly:
testq %rsi, %rsi
je 0x11f5
xorl %ecx, %ecx
xorl %eax, %eax
movzbl (%rdi,%rcx), %edx
addq %rdx, %rax
incq %rcx
cmpq %rcx, %rsi
jne 0x11e5
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %r13
shlq $0x4, %r13
leaq 0x28(,%rdi,8), %r15
addq %r13, %r15
movq %r15, %rdi
callq 0x10c0
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1090
leaq 0x28(%r12), %rax
movq %rax, (%r12)
movq %r14, 0x10(%r12)
movq $0x0, 0x18(%r12)
testq %rbx, %rbx
leaq -0x76(%rip), %rax       # 0x11dc
cmovneq %rbx, %rax
movq %rax, 0x20(%r12)
leaq (%r12,%r13), %rax
addq $0x28, %rax
movq %rax, 0x8(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12d9
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax,%r12,8)
je 0x12d1
movq (%rbx), %r14
movq %r12, %r13
shlq $0x4, %r13
movq (%r14,%r13), %rdi
callq 0x1030
movq 0x8(%r14,%r13), %r14
testq %r14, %r14
je 0x12d1
movq (%r14), %rdi
callq 0x1030
movq 0x8(%r14), %r13
movq %r14, %rdi
callq 0x1030
movq %r13, %r14
testq %r13, %r13
jne 0x12b5
incq %r12
cmpq %r15, %r12
jne 0x128d
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x13f3
movq %r8, %rbp
movq %rdx, %r12
movq %rdi, %rbx
movq %rsi, %rdi
movq %rsi, %r14
movq %rdx, %rsi
callq *%rax
xorl %edx, %edx
divq 0x10(%rbx)
movq %rdx, 0x8(%rsp)
leaq (%r12,%rbp), %rdi
addq $0x20, %rdi
callq 0x10c0
movq %rax, %r15
leaq 0x20(%rax), %rdi
movq %rdi, (%rax)
movq %r12, 0x8(%rax)
leaq 0x20(%rax,%r12), %r13
movq %r13, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r14, (%rsp)
movq %r14, %rsi
movq 0x8(%rsp), %r14
movq %r12, %rdx
callq 0x10b0
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0x10b0
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %r13
movq %r14, %rdi
shlq $0x4, %rdi
addq (%rbx), %rdi
testq %r13, %r13
jne 0x13b5
cmpq $0x0, 0x8(%rdi)
jne 0x1412
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movq 0x8(%rbx), %rax
movq %rdi, (%rax,%r14,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x1431
movq %rax, %r12
testq %rax, %rax
je 0x13d8
movq (%r12), %rdi
callq 0x1030
movq %r15, (%r12)
jmp 0x13e9
movl $0x10, %edi
callq 0x10c0
movq %rax, 0x8(%r13)
movq %rax, %r13
movq %r13, %rdi
testq %r12, %r12
jne 0x13a6
jmp 0x1393
leaq 0xc0a(%rip), %rdi       # 0x2004
leaq 0xc16(%rip), %rsi       # 0x2017
leaq 0xc1f(%rip), %rcx       # 0x2027
movl $0x6c, %edx
callq 0x1080
leaq 0xc5b(%rip), %rdi       # 0x2074
leaq 0xbf7(%rip), %rsi       # 0x2017
leaq 0xc00(%rip), %rcx       # 0x2027
movl $0x8d, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x145f
cmpq %r14, 0x8(%rax)
jne 0x145f
movq (%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10d0
testl %eax, %eax
je 0x146a
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x143f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1514
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 0x150b
shlq $0x4, %rdx
addq (%r15), %rdx
movq %rdx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1431
testq %rax, %rax
je 0x1509
movq (%rax), %rcx
jmp 0x150b
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0xae9(%rip), %rdi       # 0x2004
leaq 0xaf5(%rip), %rsi       # 0x2017
leaq 0xb5e(%rip), %rcx       # 0x2087
movl $0xd0, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 $0xb71b28, %edi         # imm = 0xB71B28
callq 0x10c0
movq %rax, %rbx
movl $0xb71b28, %edx         # imm = 0xB71B28
movq %rax, %rdi
xorl %esi, %esi
callq 0x1090
leaq 0x28(%rbx), %rax
movq %rax, (%rbx)
movq $0x7a120, 0x10(%rbx)    # imm = 0x7A120
movq $0x0, 0x18(%rbx)
leaq -0x3ea(%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 0xac7(%rip), %rsi       # 0x20bd
movl $0x65, %edx
movq %rbx, %rdi
callq 0x14b8
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 0xab5(%rip), %rdi       # 0x2122
xorl %eax, %eax
callq 0x1070
testq %r14, %r14
je 0x167f
movq 0x10(%r14), %rdi
jmp 0x1686
leaq 0xaa6(%rip), %rdi       # 0x212c
callq 0x1040
movq %rbx, %rdi
callq 0x1275
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rdi
movl $0x20, %esi
movq %rdi, %rdx
xorl %ecx, %ecx
callq 0x126c
testl %eax, %eax
jne 0x11e5
movdqa (%rsp), %xmm0
movdqa 0x10(%rsp), %xmm1
pcmpeqb 0xe87(%rip), %xmm1      # 0x2010
pcmpeqb 0xe8f(%rip), %xmm0      # 0x2020
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x1204
movq %rsp, %rdi
movl $0x20, %esi
movq %rdi, %rdx
xorl %ecx, %ecx
callq 0x1368
testl %eax, %eax
jne 0x1223
movdqa (%rsp), %xmm0
movdqa 0x10(%rsp), %xmm1
pcmpeqb 0xe67(%rip), %xmm1      # 0x2030
pcmpeqb 0xe6f(%rip), %xmm0      # 0x2040
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x1242
addq $0x28, %rsp
retq
leaq 0xea4(%rip), %rdi       # 0x2090
leaq 0xeaa(%rip), %rsi       # 0x209d
leaq 0xeb0(%rip), %rcx       # 0x20aa
movl $0x1b, %edx
callq 0x1030
leaq 0xeb1(%rip), %rdi       # 0x20bc
leaq 0xe8b(%rip), %rsi       # 0x209d
leaq 0xe91(%rip), %rcx       # 0x20aa
movl $0x1c, %edx
callq 0x1030
leaq 0xe66(%rip), %rdi       # 0x2090
leaq 0xe6c(%rip), %rsi       # 0x209d
leaq 0xe72(%rip), %rcx       # 0x20aa
movl $0x1f, %edx
callq 0x1030
leaq 0xe9e(%rip), %rdi       # 0x20e7
leaq 0xe4d(%rip), %rsi       # 0x209d
leaq 0xe53(%rip), %rcx       # 0x20aa
movl $0x20, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 0x3e2b(%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 0x328d
movl $0x1, %esi
callq 0x21f0
xorps %xmm0, %xmm0
cvtsi2ssl 0x1c(%rbx), %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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x32e0
movl $0x1, %esi
callq 0x21f0
xorps %xmm0, %xmm0
cvtsi2ssl 0x1c(%rbx), %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_O1/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 0x3d74(%rip), %xmm1     # 0x7094
movss %xmm1, 0x18(%rdi)
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x3338
movl $0x1, %esi
callq 0x21f0
xorps %xmm0, %xmm0
cvtsi2ssl 0x1c(%rbx), %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_O1/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 0x3110
leaq 0x4f2d(%rip), %rax      # 0x9cd8
movq %rax, (%rbx)
movsd 0x22fa(%rip), %xmm0     # 0x70b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x4e74
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3110
leaq 0x4eca(%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 0x4e74
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x33ac
movss 0x8(%rbx), %xmm2
movss 0x10(%rbx), %xmm0
divss %xmm0, %xmm2
movss %xmm2, 0x8(%rsp)
movss 0x21f7(%rip), %xmm1     # 0x7094
mulss %xmm2, %xmm1
movss %xmm1, 0xc(%rsp)
movss %xmm1, 0x18(%rbx)
divss 0xc(%rbx), %xmm0
cvtss2sd %xmm0, %xmm0
addsd 0x2213(%rip), %xmm0     # 0x70d0
callq 0x2320
xorps %xmm1, %xmm1
cvtss2sd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x21f9(%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_O1/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 0x3110
leaq 0x47f9(%rip), %rax      # 0x9d20
movq %rax, (%rbx)
movsd 0x1b7e(%rip), %xmm0     # 0x70b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x55f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x3110
leaq 0x4796(%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 0x55f0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x33ac
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 0x1aa9(%rip), %xmm0     # 0x70d0
callq 0x2320
xorps %xmm1, %xmm1
cvtss2sd 0xc(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x1a8f(%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_O1/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 0x3110
leaq 0x40b5(%rip), %rax      # 0x9d68
movq %rax, (%rbx)
movsd 0x13f2(%rip), %xmm0     # 0x70b0
movsd %xmm0, 0x8(%rbx)
movl $0x44ed8000, 0x10(%rbx) # imm = 0x44ED8000
movq %rbx, %rdi
callq 0x5d7c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x2350
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1af83
movslq 0x18(%r14), %r15
incq %rdi
callq 0x41d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rcx
je 0x1afa6
movq 0x38(%r14), %rcx
leaq 0x7a64e(%rip), %rsi     # 0x955bc
leaq 0x7a67e(%rip), %rdx     # 0x955f3
movl %ebp, %edi
movq %rbx, %r8
xorl %eax, %eax
callq 0xe394
jmp 0x1afa1
movq 0x38(%r14), %r9
leaq 0x7a62e(%rip), %rsi     # 0x955bc
leaq 0x7a637(%rip), %rdx     # 0x955cc
movl %ebp, %edi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xe394
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x1b052(%rip), %rdi     # 0x20379
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 0x1b01e(%rip), %rdi     # 0x2038b
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_O1/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 0x65b3
addq $0x2, %r15
movq %r15, %r14
jmp 0x65f7
movq %rdx, %rbx
leal 0x1(%r12), %ecx
movl %ecx, (%rdx)
cmpl %edi, %ecx
jge 0x65e0
movq 0x8(%rsi,%rax,8), %r14
cmpb $0x2d, (%r14)
jne 0x65f7
callq 0x5290
movq (%rax), %rax
movzbl 0x1(%r14), %ecx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x65f7
movl %r12d, (%rbx)
movsbl 0x1(%r15), %esi
xorl %r14d, %r14d
movl $0x5, %edi
xorl %eax, %eax
callq 0x6f84
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19c69(%rip), %rsi     # 0x20281
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0x664a
leaq 0x19c60(%rip), %rsi     # 0x2028b
movq %r14, %rdi
callq 0x5160
testl %eax, %eax
je 0x6650
xorl %ebp, %ebp
movl $0x2, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6f84
jmp 0x6654
movw $0x1, %bp
jmp 0x6654
movw $0x2, %bp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x668a
movl $0x1, %edi
xorl %eax, %eax
callq 0x6f84
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x66b1
movl $0x1, %edi
xorl %eax, %eax
callq 0x6f84
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x19aef(%rip), %rsi     # 0x202a0
callq 0x5220
testq %rax, %rax
je 0x6872
movq %rax, %r14
movq %rax, %rdi
callq 0x5190
testq %rax, %rax
js 0x6806
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x51f0
testl %eax, %eax
js 0x6806
movq %r14, %rdi
callq 0x5190
testq %rax, %rax
js 0x6806
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x51f0
testl %eax, %eax
jns 0x6820
movq %r14, %rdi
callq 0x50c0
xorl %r15d, %r15d
movl $0x5, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6f84
leaq 0x9(%r15), %rdi
callq 0x6668
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 0x6868
movq %r14, %rdi
callq 0x50c0
movl $0x7, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x6f84
movq %r14, %rdi
callq 0x50c0
jmp 0x6875
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x68d0
movzbl -0x1(%rbx,%rsi), %edi
addq %rax, %rcx
cmpl $0x3a, %edi
je 0x68c9
movq %rdx, %rsi
cmpl $0x2f, %edi
jne 0x68ae
sarq $0x20, %rcx
addq %rcx, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6928
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 0x693b
leaq 0x19974(%rip), %rdi     # 0x202a3
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x52b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/deplinenoise[P]vlink/support.c
// Function: write16
void write16(bool be,void *p,uint16_t d)
{
  if (be)
    write16be(p,d);
  else
    write16le(p,d);
}

// Assembly:
testl %edi, %edi
je 0x6a0d
movb %dh, (%rsi)
jmp 0x6a15
movb %dl, (%rsi)
movzwl %dx, %edx
shrl $0x8, %edx
movb %dl, 0x1(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edi, %edi
je 0x6a31
movl %edx, %eax
shrl $0x18, %eax
movb %al, (%rsi)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x1(%rsi)
movb %dh, 0x2(%rsi)
jmp 0x6a41
movb %dl, (%rsi)
movb %dh, 0x1(%rsi)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rsi)
shrl $0x18, %edx
movb %dl, 0x3(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edi, %edi
je 0x6a85
movq %rdx, %rax
shrq $0x38, %rax
movb %al, (%rsi)
movq %rdx, %rax
shrq $0x30, %rax
movb %al, 0x1(%rsi)
movq %rdx, %rax
shrq $0x28, %rax
movb %al, 0x2(%rsi)
movq %rdx, %rax
shrq $0x20, %rax
movb %al, 0x3(%rsi)
movl %edx, %eax
shrl $0x18, %eax
movb %al, 0x4(%rsi)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x5(%rsi)
movb %dh, 0x6(%rsi)
jmp 0x6abc
movb %dl, (%rsi)
movb %dh, 0x1(%rsi)
movl %edx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rsi)
movl %edx, %eax
shrl $0x18, %eax
movb %al, 0x3(%rsi)
movq %rdx, %rax
shrq $0x20, %rax
movb %al, 0x4(%rsi)
movq %rdx, %rax
shrq $0x28, %rax
movb %al, 0x5(%rsi)
movq %rdx, %rax
shrq $0x30, %rax
movb %al, 0x6(%rsi)
shrq $0x38, %rdx
movb %dl, 0x7(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x286b4(%rip), %rcx     # 0x2f180
movq (%rcx,%rax,8), %rcx
movb 0xaa(%rcx), %al
movzbl 0xab(%rcx), %ecx
cmpl $0x40, %ecx
je 0x6b0d
cmpl $0x20, %ecx
je 0x6afe
cmpl $0x10, %ecx
jne 0x6b21
cmpb $0x1, %al
jne 0x6af4
rolw $0x8, %dx
movw %dx, (%rsi)
movl $0x2, %ebx
jmp 0x6b34
cmpb $0x1, %al
jne 0x6b04
bswapl %edx
movl %edx, (%rsi)
movl $0x4, %ebx
jmp 0x6b34
xorl %edi, %edi
cmpb $0x1, %al
sete %dil
callq 0x6a45
movl $0x8, %ebx
jmp 0x6b34
movsbl %cl, %esi
leaq 0x1979a(%rip), %rdi     # 0x202c5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x52b0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b79
leal (%rcx,%rdx), %eax
cmpl $0x20, %eax
jg 0x6b79
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
notl %r8d
movzbl (%rsi), %ecx
testl %edi, %edi
je 0x6b8f
shll $0x18, %ecx
movzbl 0x1(%rsi), %edx
shll $0x10, %edx
orl %ecx, %edx
movzbl 0x2(%rsi), %ecx
shll $0x8, %ecx
orl %edx, %ecx
movzbl 0x3(%rsi), %ebx
orl %ecx, %ebx
negb %al
movl %eax, %ecx
jmp 0x6bac
leaq 0x1976e(%rip), %rdi     # 0x202ee
xorl %ebx, %ebx
movl %edx, %esi
movl %ecx, %edx
xorl %eax, %eax
callq 0x52b0
jmp 0x6bb1
movzbl 0x1(%rsi), %eax
shll $0x8, %eax
movzbl 0x2(%rsi), %edi
shll $0x10, %edi
orl %eax, %edi
movzbl 0x3(%rsi), %ebx
shll $0x18, %ebx
orl %edi, %ebx
orl %ecx, %ebx
movl %edx, %ecx
shrl %cl, %ebx
andl %r8d, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6bf0
leal (%rcx,%rdx), %eax
cmpl $0x20, %eax
jg 0x6bf0
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
shll %cl, %r9d
notl %r9d
testl %edi, %edi
je 0x6c02
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 0x6c16
leaq 0x19728(%rip), %rdi     # 0x2031f
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_O1/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 0x6c3b
movq %rsi, %rax
movq %rdi, %rbx
movl $0x1, %esi
movq %rax, %rdi
movq %rbx, %rcx
callq 0x5270
testq %rax, %rax
je 0x6c3d
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x29f4c(%rip), %rax     # 0x30b98
movq 0x48(%rax), %rsi
movl $0x1f, %edi
xorl %eax, %eax
popq %rbx
jmp 0x6f84
// File: /workspace/github_c_makefile_star2_O1/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 0x6c8b
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x29efe(%rip), %rax     # 0x30b98
movq 0x48(%rax), %rsi
movl $0x1f, %edi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6f84
// File: /workspace/github_c_makefile_star2_O1/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 0x6ce0
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
callq 0x50c0
leaq 0x29ea9(%rip), %rax     # 0x30b98
movq 0x48(%rax), %rsi
movl $0x1f, %edi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
jmp 0x6f84
// File: /workspace/github_c_makefile_star2_O1/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 0x6d8f
leaq 0x195ce(%rip), %rdi     # 0x20351
movl $0x2000, %esi           # imm = 0x2000
xorl %eax, %eax
callq 0x52b0
movl %r14d, %edx
leaq 0x2a057(%rip), %rsi     # 0x30df0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c1a
// File: /workspace/github_c_makefile_star2_O1/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 0x6c1a
leaq -0x400(%r14), %rax
cmpq %r12, %r14
movq %rax, %r14
jg 0x6dd4
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e3d
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 0x6e14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6e9b
xorl %eax, %eax
movl %eax, %ecx
leal 0x1(%rcx), %eax
cmpl $0x1e, %ecx
ja 0x6e9b
movl %edi, %ecx
shrl %ecx
andl $0x2, %edi
movl %ecx, %edi
je 0x6e86
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ec7
xorl %eax, %eax
movl %eax, %ecx
leal 0x1(%rcx), %eax
cmpl $0x3e, %ecx
ja 0x6ec7
movq %rdi, %rcx
sarq %rcx
andl $0x2, %edi
movq %rcx, %rdi
je 0x6eaf
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6f16
movzbl 0x50(%rdi), %eax
leaq 0x282a8(%rip), %rdi     # 0x2f180
movq (%rdi,%rax,8), %rax
cmpb $0x1, 0xaa(%rax)
jne 0x6eeb
movb %dh, -0x2(%rsp)
jmp 0x6ef5
movzwl %dx, %edx
movb %dl, -0x2(%rsp)
shrl $0x8, %edx
movb %dl, -0x1(%rsp)
movl %esi, %eax
andl $0x1, %eax
xorl %edx, %edx
movl %eax, %edi
movb -0x2(%rsp,%rdi), %dil
movb %dil, (%rsi,%rdx)
xorl $0x1, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x6f00
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10, %edi
callq 0x51c0
movq %rax, %r14
testq %rax, %rax
jne 0x6f60
movl $0x1, %edi
xorl %eax, %eax
callq 0x6f84
movq $0x0, (%r14)
movq %r15, 0x8(%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0x6f7b
movq %rax, %rbx
movq (%rax), %rax
jmp 0x6f6e
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %r15
retq