LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/waynebhayes[P]SAHap/src/InputReader.cpp
// Function: SAHap::WIFInputReader::parseSNP(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Site WIFInputReader::parseSNP(string snp) {
	istringstream iss(snp);
	Site s;
	iss >> s.pos;

	iss.ignore(256, ' ');
	iss.ignore(256, ' ');

	int weight, value;
	iss >> value >> weight;

	if (s.weight <= 0 || s.weight > 100) {
	// 	s.weight = (double)weight/100;
	// } else 
		throw "Invalid weight value";
	}
	//s.weight = 1; // HACK
	s.value = value;
	// if (value == 0) {
	// 	s.value = Allele::REF;
	// } else if (value == 1) {
	// 	s.value = Allele::ALT;
	// } else {
	// 	cout << value << endl;
	// 	throw "Invalid allele value";
	// }
	return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2400
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
movl $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x2130
leaq 0x8(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2170
leaq 0x8(%rsp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x2170
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x2150
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x2150
movl 0x10(%rbx), %eax
addl $-0x65, %eax
cmpl $-0x65, %eax
jbe 0x91c4
movl (%rsp), %eax
movl %eax, (%rbx)
movq 0x6e21(%rip), %rsi      # 0xffc0
leaq 0x8(%rsp), %rdi
callq 0x2340
leaq 0x80(%rsp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
retq
movl $0x8, %edi
callq 0x2100
leaq 0x2628(%rip), %rcx      # 0xb7fd
movq %rcx, (%rax)
movq 0x6dd1(%rip), %rsi      # 0xffb0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2420
jmp 0x91eb
movq %rax, %rbx
movq 0x6dcb(%rip), %rsi      # 0xffc0
leaq 0x8(%rsp), %rdi
callq 0x2340
leaq 0x80(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2450
// File: /workspace/github_c_makefile_star2_O1/waynebhayes[P]SAHap/src/utils.cpp
// Function: log_poisson_pmf
double log_poisson_pmf(double l, unsigned k) {
  double r = -l;

  for (auto i = k; i > 0; i--) {
    r += log(l/i);
  }

  return r;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm2
movapd 0x775(%rip), %xmm0      # 0xb0e0
xorpd %xmm2, %xmm0
testl %edi, %edi
je 0xa9b4
movl %edi, %ebx
movapd %xmm2, 0x10(%rsp)
movapd %xmm0, (%rsp)
movl %ebx, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x2200
movapd 0x10(%rsp), %xmm2
movapd (%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
movapd (%rsp), %xmm0
decl %ebx
jne 0xa97b
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/waynebhayes[P]SAHap/src/utils.cpp
// Function: log_poisson_1_cdf
double log_poisson_1_cdf(double l, unsigned k) {
#if 0
  if (log_poisson_1_cdf_l != l) {
    fill(log_poisson_1_cdf_memo, log_poisson_1_cdf_memo + 1000, 10);
    log_poisson_1_cdf_l = l;
  }

  if (k < 1000 && log_poisson_1_cdf_memo[k] < 0) {
    return log_poisson_1_cdf_memo[k];
  }
#endif
  // cout << "log_poisson_1_cdf(" << l << ", " << k << ")" << endl;

  assert(l>0);
  double pmax = 2, max = -1e30;
  for (unsigned i = k; pmax != max; ++i) {
    pmax = max;
    double logpmf = log_poisson_pmf(l, i);
    if (logpmf > max) {
      max = logpmf;
    }
  }

  double r = (max == 1 && k < l) ? 0 : max / .894;

  /*
  if (k < 1000) {
    log_poisson_1_cdf_memo[k] = r;
  }

  cout << "k = " << k << ", r = " << r << endl;
  */

  return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jbe 0xaa97
movl %edi, %ebx
movapd 0x702(%rip), %xmm0      # 0xb0e0
xorpd %xmm2, %xmm0
movapd %xmm0, 0x10(%rsp)
movsd 0xe90(%rip), %xmm0      # 0xb880
movl %edi, %ebp
movapd %xmm2, 0x20(%rsp)
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm3
testl %ebp, %ebp
je 0xaa42
movl %ebp, %r14d
movaps 0x10(%rsp), %xmm3
movaps %xmm3, 0x30(%rsp)
movl %r14d, %eax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm2
movapd %xmm2, %xmm0
callq 0x2200
movapd 0x30(%rsp), %xmm3
movapd 0x20(%rsp), %xmm2
addsd %xmm0, %xmm3
decl %r14d
jne 0xaa10
movsd 0x8(%rsp), %xmm0
maxsd %xmm0, %xmm3
incl %ebp
ucomisd %xmm3, %xmm0
movapd %xmm3, %xmm0
jne 0xa9f8
jp 0xa9f8
movl %ebx, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movapd %xmm3, %xmm1
divsd 0xe18(%rip), %xmm1      # 0xb888
cmpeqsd 0x597(%rip), %xmm3      # 0xb010
andnpd %xmm1, %xmm3
cmpltsd %xmm2, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm0
orpd %xmm3, %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xdf2(%rip), %rdi       # 0xb890
leaq 0xdef(%rip), %rsi       # 0xb894
leaq 0xdf6(%rip), %rcx       # 0xb8a2
movl $0x43, %edx
callq 0x2180
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfspatchnoautofolder.c
// Function: usage
void usage(const char * progname)
{
	fprintf(stderr, "usage: %s <command> <file.iso>\n", progname);
	fprintf(stderr, "commands :\n");
	fprintf(stderr, "  show : only display informations\n");
	fprintf(stderr, "  disable : disable autofolder\n");
	fprintf(stderr, "  setroot : set autofolder to root\n");
	fprintf(stderr, "  setfolderid <id> : set autofolder to id * USE WITH CARE *\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rdx
movq 0x4e79(%rip), %r15      # 0x5ff8
movq (%r15), %rdi
leaq 0x1ed0(%rip), %rsi      # 0x3059
xorl %eax, %eax
callq 0x10c0
movq (%r15), %rcx
leaq 0x1edf(%rip), %rdi      # 0x3079
pushq $0xb
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1ed3(%rip), %rdi      # 0x3085
pushq $0x23
popq %r14
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1ede(%rip), %rdi      # 0x30a9
pushq $0x1f
popq %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1ee9(%rip), %rdi      # 0x30c9
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r15), %rcx
leaq 0x1ef8(%rip), %rdi      # 0x30ed
pushq $0x3c
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1140
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: hexdump
void hexdump(const unsigned char * p, unsigned int n, unsigned int a)
{
	unsigned int i, j;

	while (n > 0) {
		i = (n >= 16) ? 16 : n;
		printf("%08x: ", a);
		for (j = 0; j < i; j++) {
			printf("%02x ", (unsigned)p[j]);
		}
		for (; j < 16; j++)
			printf("   ");
		printf ("| ");
		for (j = 0; j < i; j++) {
			if (isgraph(p[j]))
				putchar(p[j]);
			else
				putchar(' ');
		}
		putchar('\n');
		n -= i;
		p += i;
		a += i;
	}
}

// Assembly:
testl %esi, %esi
je 0x1b02
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x1834(%rip), %r12      # 0x323c
cmpl $0x10, %esi
movl $0x10, %ebx
movl %esi, 0x10(%rsp)
cmovbl %esi, %ebx
leaq 0x1817(%rip), %rdi      # 0x3235
movl %edx, 0x14(%rsp)
movl %edx, %esi
xorl %eax, %eax
callq 0x1090
cmpl $0x1, %ebx
movl %ebx, %ebp
adcl $0x0, %ebp
cmpl $0x10, %ebx
movl $0xf, %r15d
movl %ebx, 0xc(%rsp)
cmovael %ebx, %r15d
movq %rbp, %r13
negq %r13
movq $-0x1, %rbx
movzbl 0x1(%r14,%rbx), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1090
leaq (%rbx,%r13), %rax
incq %rax
incq %rbx
cmpq $-0x1, %rax
jne 0x1a51
cmpq $0xe, %rbx
leaq 0x1c4d(%rip), %rbx      # 0x36c9
ja 0x1a93
subl %ebp, %r15d
incl %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1090
decl %r15d
jne 0x1a84
leaq 0x17a8(%rip), %rdi      # 0x3242
xorl %eax, %eax
callq 0x1090
callq 0x1150
movq %rax, %r15
xorl %r13d, %r13d
movq (%r15), %rcx
movzbl (%r14,%r13), %eax
cmpw $0x0, (%rcx,%rax,2)
movl $0x20, %edi
jns 0x1ac2
movl %eax, %edi
callq 0x1040
incq %r13
cmpq %r13, %rbp
jne 0x1aac
movl $0xa, %edi
callq 0x1040
movl 0xc(%rsp), %ecx
movl %ecx, %eax
addq %rax, %r14
movl 0x14(%rsp), %edx
addl %ecx, %edx
movl 0x10(%rsp), %esi
subl %ecx, %esi
jne 0x1a08
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: print_hfs_uni
static void print_hfs_uni(const unsigned char * p)
{
	uint16_t len;
	len = readu16(p);
	p += 2;
	putchar('"');
	while(len > 0) {
		if(p[0] || p[1] < 32) {
			printf("\\u%02x%02x", p[0], p[1]);
		} else {
			putchar(p[1]);
		}
		p += 2;
		len--;
	}
	putchar('"');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %ebp
movzbl 0x1(%rdi), %r14d
movl $0x22, %edi
callq 0x1040
movl %r14d, %eax
orw %bp, %ax
je 0x244f
shll $0x8, %ebp
movzwl %r14w, %eax
addl %ebp, %eax
movzwl %ax, %r15d
leaq 0x1537(%rip), %r14      # 0x394c
xorl %r12d, %r12d
movzbl 0x2(%rbx,%r12,2), %esi
testl %esi, %esi
jne 0x242d
movzbl 0x3(%rbx,%r12,2), %edi
cmpl $0x1f, %edi
ja 0x2448
movzbl 0x3(%rbx,%r12,2), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1090
incq %r12
cmpw %r12w, %r15w
jne 0x2418
jmp 0x244f
callq 0x1040
jmp 0x243d
movl $0x22, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: load_catalog
unsigned char * load_catalog(FILE * f)
{
	unsigned char * catalog;
	int offset;
	if(block_size == 0) {
		fprintf(stderr, "block_size==0 !\n");
		return 0;
	}
	if(catalog_start_block == 0) {
		fprintf(stderr, "catalog_start_block == 0 !\n");
		return 0;
	}
	if(catalog_block_count == 0) {
		fprintf(stderr, "catalog_block_count == 0 !\n");
		return 0;
	}
	offset = hfs_part_sector * SECTOR_SIZE;
	offset += block_size * catalog_start_block;
	if(fseek(f, offset, SEEK_SET) != 0) {
		perror("fseek");
		return 0;
	}
	catalog = malloc(catalog_block_count * block_size);
	if(!catalog) {
		fprintf(stderr, "memory allocation error\n");
		return 0;
	}
	if(fread(catalog, block_size, catalog_block_count, f) != catalog_block_count) {
		fprintf(stderr, "failed to read catalog file\n");
		free(catalog);
		return 0;
	}
	printf("%u bytes in catalog\n", catalog_block_count * block_size);
	return catalog;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x36b1(%rip), %eax      # 0x60cc
testl %eax, %eax
je 0x2ab2
movl 0x36a7(%rip), %ecx      # 0x60d0
testl %ecx, %ecx
je 0x2ab9
cmpl $0x0, 0x369c(%rip)      # 0x60d4
je 0x2ac0
movq %rdi, %r14
movl 0x367d(%rip), %edx      # 0x60c4
shll $0x9, %edx
imull %eax, %ecx
addl %edx, %ecx
movslq %ecx, %rsi
xorl %edx, %edx
callq 0x1100
testl %eax, %eax
jne 0x2ac7
movl 0x3670(%rip), %r15d     # 0x60d4
movl 0x3661(%rip), %r12d     # 0x60cc
movl %r12d, %edi
imull %r15d, %edi
callq 0x10d0
testq %rax, %rax
je 0x2ad5
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1070
movl 0x363e(%rip), %esi      # 0x60d4
cmpq %rsi, %rax
jne 0x2adc
imull 0x362a(%rip), %esi      # 0x60cc
leaq 0xd3e(%rip), %rdi       # 0x37e7
xorl %eax, %eax
callq 0x1090
jmp 0x2ae6
callq 0x1411
jmp 0x2ae4
callq 0x13f5
jmp 0x2ae4
callq 0x13d9
jmp 0x2ae4
leaq 0x536(%rip), %rdi       # 0x3004
callq 0x1120
jmp 0x2ae4
callq 0x13bd
jmp 0x2ae4
movq %rbx, %rdi
callq 0x1394
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: save_catalog
int save_catalog(FILE * f, unsigned char * catalog)
{
	int offset;
	if(block_size == 0) {
		fprintf(stderr, "block_size==0 !\n");
		return 0;
	}
	if(catalog_start_block == 0) {
		fprintf(stderr, "catalog_start_block == 0 !\n");
		return 0;
	}
	if(catalog_block_count == 0) {
		fprintf(stderr, "catalog_block_count == 0 !\n");
		return 0;
	}
	offset = hfs_part_sector * SECTOR_SIZE;
	offset += block_size * catalog_start_block;
	if(fseek(f, offset, SEEK_SET) != 0) {
		perror("fseek");
		return 0;
	}
	if(fwrite(catalog, block_size, catalog_block_count, f) != catalog_block_count) {
		fprintf(stderr, "failed to write to file\n");
		return 0;
	}
	if(fflush(f) != 0) {
		perror("fflush");
		return 0;
	}
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x35cd(%rip), %eax      # 0x60cc
testl %eax, %eax
je 0x2b76
movl 0x35c7(%rip), %ecx      # 0x60d0
testl %ecx, %ecx
je 0x2b7d
cmpl $0x0, 0x35c0(%rip)      # 0x60d4
je 0x2b84
movq %rsi, %r14
movq %rdi, %rbx
movl 0x35a2(%rip), %edx      # 0x60c4
shll $0x9, %edx
imull %eax, %ecx
addl %edx, %ecx
movslq %ecx, %rsi
xorl %edx, %edx
callq 0x1100
testl %eax, %eax
jne 0x2b8b
movl 0x358e(%rip), %esi      # 0x60cc
movl 0x3590(%rip), %edx      # 0x60d4
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1140
movl 0x357f(%rip), %ecx      # 0x60d4
cmpq %rcx, %rax
jne 0x2b99
movq %rbx, %rdi
callq 0x10e0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
je 0x2ba0
leaq 0xca1(%rip), %rdi       # 0x3815
jmp 0x2b92
callq 0x1481
jmp 0x2b9e
callq 0x1465
jmp 0x2b9e
callq 0x1449
jmp 0x2b9e
leaq 0x472(%rip), %rdi       # 0x3004
callq 0x1120
jmp 0x2b9e
callq 0x142d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: read_catalog
int read_catalog(FILE * f)
{
	unsigned char * catalog;
	uint32_t node;
	//struct find_infos infos;

	catalog = load_catalog(f);
	if(catalog == NULL)
		return 0;
	printf("Catalog Header Node :\n");
	if(!print_node(catalog)) {	/* header node */
		free(catalog);
		return 0;
	}
	printf("Catalog Root Node :\n");
	print_node(catalog + catalog_root_node * catalog_node_size);/* root node */
#if 0
	hfs_find(catalog, 1 /* root parent id */, NULL, &infos);
	printf("----\n");
	if(hfs_find(catalog, 2 /* root id */, "fichiers", &infos)) {
		printf("/fichiers found : id=%u\n", infos.folder_id);
		if(hfs_find(catalog, infos.folder_id, "MYRIADE_3E.app", &infos)) {
			printf("found ! flags=%04X\n", readu16(infos.p + 56));
			//found = 1;
		}
	}
#endif
	printf("Catalog Leaf Nodes :\n");
	for(node = catalog_first_leaf_node; node != 0; node = next_node(catalog, node)) {
		print_node(catalog + node * catalog_node_size);
	}
	free(catalog);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x2a0d
testq %rax, %rax
je 0x2c32
movq %rax, %rbx
leaq 0xf80(%rip), %rdi       # 0x3b40
callq 0x1060
movq %rbx, %rdi
callq 0x1f9f
testl %eax, %eax
je 0x2c36
leaq 0xf7e(%rip), %rdi       # 0x3b56
callq 0x1060
movl 0x3501(%rip), %edi      # 0x60e4
imull 0x34ee(%rip), %edi      # 0x60d8
addq %rbx, %rdi
callq 0x1f9f
leaq 0xf71(%rip), %rdi       # 0x3b6a
callq 0x1060
movl 0x34d7(%rip), %r14d     # 0x60dc
movl $0x1, %ebp
testl %r14d, %r14d
je 0x2c38
movl 0x34cf(%rip), %edi      # 0x60e4
imull %r14d, %edi
addq %rbx, %rdi
callq 0x1f9f
imull 0x34bb(%rip), %r14d     # 0x60e4
movl (%rbx,%r14), %r14d
bswapl %r14d
jmp 0x2c0a
xorl %ebp, %ebp
jmp 0x2c40
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: hfs_uni_to_str
static int hfs_uni_to_str(char * d, int n, const unsigned char * p)
{
	uint16_t len;
	int i, j;
	len = readu16(p);
	p += 2;
	for(i = 0, j = 0; i < len && j < (n - 1); i++) {
		if(p[0] || p[1] < 32) {
			j += snprintf(d + j, 7, "\\u%02x%02x", p[0], p[1]);
		} else {
			d[j++] = p[1];
		}
		p += 2;
	}
	d[j++] = '\0';
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl (%rsi), %ecx
rolw $0x8, %cx
xorl %eax, %eax
testw %cx, %cx
je 0x2f6e
movq %rsi, %r14
movzwl %cx, %ebp
movl $0x1, %r12d
leaq 0xa31(%rip), %r15       # 0x394c
xorl %r13d, %r13d
movzbl (%r14,%r12,2), %ecx
movslq %r13d, %rdi
testl %ecx, %ecx
jne 0x2f33
movb 0x1(%r14,%r12,2), %al
cmpb $0x1f, %al
ja 0x2f61
addq %rbx, %rdi
movzbl 0x1(%r14,%r12,2), %r8d
movl $0x7, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x10a0
addl %eax, %r13d
cmpl %ebp, %r12d
jae 0x2f6b
incq %r12
cmpl $0xff, %r13d
jl 0x2f1e
jmp 0x2f6b
movb %al, (%rbx,%rdi)
movl $0x1, %eax
jmp 0x2f4b
movslq %r13d, %rax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DASmap.c
// Function: init_file_iterator
File_Iterator *init_file_iterator(FILE *input)
{ File_Iterator *it;

  it = Malloc(sizeof(File_Iterator),"Allocating file iterator");
  it->input = input;
  it->lineno = 1;
  rewind(input);
  return (it);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8c9a(%rip), %rsi      # 0xb004
movl $0x18, %edi
callq 0x2b85
movq %rax, %r14
movq %rbx, (%rax)
movl $0x1, 0x8(%rax)
movq %rbx, %rdi
callq 0x1110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DASmap.c
// Function: next_read
int next_read(File_Iterator *it)
{ static char nbuffer[MAX_BUFFER];

  char *eol;
  int   x;

  if (fgets(nbuffer,MAX_BUFFER,it->input) == NULL)
    { if (feof(it->input))
        return (1);
      SYSTEM_READ_ERROR;
    }
  if ((eol = index(nbuffer,'\n')) == NULL)
    { fprintf(stderr,"%s: Line %d in read list is longer than %d chars!\n",
                     Prog_Name,it->lineno,MAX_BUFFER-1);
      return (1);
    }
  *eol = '\0';
  x = sscanf(nbuffer," %d %d %d",&(it->read),&(it->beg),&(it->end));
  if (x == 1)
    it->beg = -1;
  else if (x != 3)
    { fprintf(stderr,"%s: Line %d of read list is improperly formatted\n",Prog_Name,it->lineno);
      return (1);
    }
  it->lineno += 1;
  return (0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdx
leaq 0xde2b(%rip), %rdi      # 0x101d0
movl $0x2711, %esi           # imm = 0x2711
callq 0x1180
testq %rax, %rax
je 0x2409
leaq 0xde15(%rip), %rdi      # 0x101d0
movl $0xa, %esi
callq 0x1140
testq %rax, %rax
je 0x2421
movb $0x0, (%rax)
leaq 0xc(%rbx), %rdx
leaq 0x10(%rbx), %r14
leaq 0x14(%rbx), %r8
leaq 0xddf0(%rip), %rdi      # 0x101d0
leaq 0x8c89(%rip), %rsi      # 0xb070
xorl %ebp, %ebp
movq %r14, %rcx
xorl %eax, %eax
callq 0x1200
cmpl $0x3, %eax
je 0x2404
cmpl $0x1, %eax
jne 0x242b
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
incl 0x8(%rbx)
jmp 0x241a
movq (%rbx), %rdi
callq 0x11b0
movl $0x1, %ebp
testl %eax, %eax
je 0x243a
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x12e8
jmp 0x2433
movq %rbx, %rdi
callq 0x12c0
movl $0x1, %ebp
jmp 0x241a
callq 0x1316
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Count_Args
int Count_Args(char *var)
{ int   cnt, lev;
  char *s;

  cnt = 1;
  lev = 0;
  for (s = var; *s != '\0'; s++)
    if (*s == ',')
      { if (lev == 0)
          cnt += 1;
      }
    else if (*s == '(')
      lev += 1;
    else if (*s == ')')
      lev -= 1;
  return (cnt);
}

// Assembly:
xorl %ecx, %ecx
movl $0x1, %eax
movzbl (%rdi), %edx
cmpl $0x28, %edx
jle 0x2b71
cmpl $0x29, %edx
je 0x2b77
cmpl $0x2c, %edx
jne 0x2b7f
cmpl $0x1, %ecx
adcl $0x0, %eax
jmp 0x2b7f
jne 0x2b7b
incl %ecx
jmp 0x2b7f
decl %ecx
jmp 0x2b7f
testl %edx, %edx
je 0x2b84
incq %rdi
jmp 0x2b57
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Malloc
void *Malloc(int64 size, char *mesg)
{ void *p;

  if ((p = malloc(size)) == NULL)
    { if (mesg == NULL)
        EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
      else
        EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
    }
  return (p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x11f0
movq %rax, %rbx
testq %rax, %rax
je 0x2ba4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd44d(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0xfd33(%rip), %rdx      # 0x128e8
testq %r14, %r14
jne 0x2bca
leaq 0x868f(%rip), %rsi      # 0xb250
xorl %eax, %eax
callq 0x11a0
jmp 0x2b99
leaq 0x8692(%rip), %rsi      # 0xb263
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x2b99
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Realloc
void *Realloc(void *p, int64 size, char *mesg)
{ if (size <= 0)
    size = 1;
  if ((p = realloc(p,size)) == NULL)
    { if (mesg == NULL)
        EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
      else
        EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
    }
  return (p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpq $0x2, %rsi
movl $0x1, %eax
cmovlq %rax, %rsi
callq 0x1210
movq %rax, %rbx
testq %rax, %rax
je 0x2c09
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd3e8(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0xfcce(%rip), %rdx      # 0x128e8
testq %r14, %r14
jne 0x2c2f
leaq 0x862a(%rip), %rsi      # 0xb250
xorl %eax, %eax
callq 0x11a0
jmp 0x2bfe
leaq 0x862d(%rip), %rsi      # 0xb263
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x2bfe
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Strdup
char *Strdup(char *name, char *mesg)
{ char *s;

  if (name == NULL)
    return (NULL);
  if ((s = strdup(name)) == NULL)
    { if (mesg == NULL)
        EPRINTF(EPLACE,"%s: Out of memory\n",Prog_Name);
      else
        EPRINTF(EPLACE,"%s: Out of memory (%s)\n",Prog_Name,mesg);
    }
  return (s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2c81
movq %rsi, %r14
callq 0x1290
movq %rax, %rbx
testq %rax, %rax
jne 0x2c83
movq 0xd396(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0xfc7c(%rip), %rdx      # 0x128e8
testq %r14, %r14
jne 0x2c8e
leaq 0x85d8(%rip), %rsi      # 0xb250
xorl %eax, %eax
callq 0x11a0
jmp 0x2c83
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x85ce(%rip), %rsi      # 0xb263
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x2c83
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Fopen
FILE *Fopen(char *name, char *mode)
{ FILE *f;

  if (name == NULL || mode == NULL)
    return (NULL);
  if ((f = fopen(name,mode)) == NULL)
    EPRINTF(EPLACE,"%s: Cannot open %s for '%s'\n",Prog_Name,name,mode);
  return (f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x2cbb
xorl %r14d, %r14d
jmp 0x2cce
movq %rsi, %rbx
movq %rdi, %r15
callq 0x1240
movq %rax, %r14
testq %rax, %rax
je 0x2cd7
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xd31a(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq 0xfc00(%rip), %rdx      # 0x128e8
leaq 0x858c(%rip), %rsi      # 0xb27b
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x11a0
jmp 0x2cce
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: PathTo
char *PathTo(char *name)
{ char *path, *find;

  if (name == NULL)
    return (NULL);
  if ((find = rindex(name,'/')) != NULL)
    { *find = '\0';
      path = Strdup(name,"Extracting path from");
      *find = '/';
    }
  else
    path = Strdup(".","Allocating default path");
  return (path);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d34
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x1250
testq %rax, %rax
je 0x2d3e
movq %rax, %r14
movb $0x0, (%rax)
leaq 0x8572(%rip), %rsi      # 0xb298
movq %rbx, %rdi
callq 0x2c42
movb $0x2f, (%r14)
jmp 0x2d36
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x87a9(%rip), %rdi      # 0xb4ee
leaq 0x8561(%rip), %rsi      # 0xb2ad
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c42
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Root
char *Root(char *name, char *suffix)
{ char *path, *find, *dot;
  int   epos;

  if (name == NULL)
    return (NULL);
  find = rindex(name,'/');
  if (find == NULL)
    find = name;
  else
    find += 1;
  if (suffix == NULL)
    { dot = strchr(find,'.');
      if (dot != NULL)
        *dot = '\0';
      path = Strdup(find,"Extracting root from");
      if (dot != NULL)
        *dot = '.';
    }
  else
    { epos  = strlen(find);
      epos -= strlen(suffix);
      if (epos > 0 && strcasecmp(find+epos,suffix) == 0)
        { find[epos] = '\0';
          path = Strdup(find,"Extracting root from");
          find[epos] = suffix[0];
        }
      else
        path = Strdup(find,"Allocating root");
    }
  return (path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2dca
movq %rsi, %r14
movq %rdi, %r15
movl $0x2f, %esi
callq 0x1250
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %r15, %rbx
movq %rbx, %rdi
testq %r14, %r14
je 0x2dce
callq 0x10e0
movq %rax, %r15
movq %r14, %rdi
callq 0x10e0
subq %rax, %r15
testl %r15d, %r15d
jle 0x2db6
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
addq %rbx, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
je 0x2dfe
leaq 0x851d(%rip), %rsi      # 0xb2da
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2c42
xorl %eax, %eax
jmp 0x2e17
movl $0x2e, %esi
callq 0x10f0
movq %rax, %r14
testq %rax, %rax
je 0x2de4
movb $0x0, (%r14)
leaq 0x84da(%rip), %rsi      # 0xb2c5
movq %rbx, %rdi
callq 0x2c42
testq %r14, %r14
je 0x2e17
movb $0x2e, (%r14)
jmp 0x2e17
movb $0x0, (%r15)
leaq 0x84bc(%rip), %rsi      # 0xb2c5
movq %rbx, %rdi
callq 0x2c42
movb (%r14), %cl
movb %cl, (%r15)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Catenate
char *Catenate(char *path, char *sep, char *root, char *suffix)
{ static char *cat = NULL;
  static int   max = -1;
  int   len;

  if (path == NULL || root == NULL || sep == NULL || suffix == NULL)
    return (NULL);
  len =  strlen(path);
  len += strlen(sep);
  len += strlen(root);
  len += strlen(suffix);
  if (len > max)
    { max = ((int) (1.2*len)) + 100;
      cat = (char *) realloc(cat,max+1);
      if (cat == NULL)
        { EPRINTF(EPLACE,"%s: Out of memory (Making path name for %s)\n",Prog_Name,root);
          return (NULL);
        }
    }
  sprintf(cat,"%s%s%s%s",path,sep,root,suffix);
  return (cat);
}

// Assembly:
xorl %eax, %eax
testq %rcx, %rcx
je 0x2f00
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rsi, %rsi
je 0x2ef2
movq %rdi, %r12
testq %rdi, %rdi
je 0x2ef2
movq %rdx, %rbx
testq %rdx, %rdx
je 0x2ef2
movq %rcx, %r14
movq %r12, %rdi
callq 0x10e0
movq %rax, %r13
movq %r15, %rdi
callq 0x10e0
movq %rax, %rbp
addl %r13d, %ebp
movq %rbx, %rdi
callq 0x10e0
movq %rax, %r13
movq %r14, %rdi
callq 0x10e0
addl %r13d, %eax
addl %ebp, %eax
cmpl %eax, 0xd317(%rip)      # 0x101a8
jge 0x2eca
cvtsi2sd %eax, %xmm0
mulsd 0x83a9(%rip), %xmm0     # 0xb248
cvttsd2si %xmm0, %eax
leal 0x64(%rax), %ecx
movl %ecx, 0xd2fc(%rip)      # 0x101a8
movq 0xfa3d(%rip), %rdi      # 0x128f0
addl $0x65, %eax
movslq %eax, %rsi
callq 0x1210
movq %rax, 0xfa2b(%rip)      # 0x128f0
testq %rax, %rax
je 0x2f01
movq 0xfa1f(%rip), %rdi      # 0x128f0
leaq 0x843f(%rip), %rsi      # 0xb317
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x1260
movq 0xf9fe(%rip), %rax      # 0x128f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1341
xorl %eax, %eax
jmp 0x2ef2
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Numbered_Suffix
char *Numbered_Suffix(char *left, int num, char *right)
{ static char *sfx = NULL;
  static int   max = -1;
  int   len;

  if (left == NULL || right == NULL)
    return (NULL);
  len =  strlen(left);
  len += strlen(right) + 40;
  if (len > max)
    { max = ((int) (1.2*len)) + 100;
      sfx = (char *) realloc(sfx,max+1);
      if (sfx == NULL)
        { EPRINTF(EPLACE,"%s: Out of memory (Making number suffix for %d)\n",Prog_Name,num);
          return (NULL);
        }
    }
  sprintf(sfx,"%s%d%s",left,num,right);
  return (sfx);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x2f20
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x10e0
movq %rax, %r12
movq %r14, %rdi
callq 0x10e0
addl %r12d, %eax
addl $0x28, %eax
cmpl %eax, 0xd260(%rip)      # 0x101ac
jge 0x2f85
cvtsi2sd %eax, %xmm0
mulsd 0x82ee(%rip), %xmm0     # 0xb248
cvttsd2si %xmm0, %eax
leal 0x64(%rax), %ecx
movl %ecx, 0xd245(%rip)      # 0x101ac
movq 0xf98a(%rip), %rdi      # 0x128f8
addl $0x65, %eax
movslq %eax, %rsi
callq 0x1210
movq %rax, 0xf978(%rip)      # 0x128f8
testq %rax, %rax
je 0x2fb5
movq 0xf96c(%rip), %rdi      # 0x128f8
leaq 0x83be(%rip), %rsi      # 0xb351
movq %r15, %rdx
movl %ebx, %ecx
movq %r14, %r8
xorl %eax, %eax
callq 0x1260
movq 0xf94f(%rip), %rax      # 0x128f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %ebx, %edi
callq 0x1363
xorl %eax, %eax
jmp 0x2fa9
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Number_Digits
int  Number_Digits(int64 num)
{ int digit;

  digit = 0;
  while (num >= 1)
    { num /= 10;
      digit += 1;
    }
  return (digit);
}

// Assembly:
xorl %ecx, %ecx
testq %rdi, %rdi
jle 0x339d
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %rsi
shrq $0x3, %rdx
incl %ecx
cmpq $0x9, %rdi
movq %rdx, %rdi
ja 0x3388
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Compress_Read
void Compress_Read(int len, char *s)
{ int   i;
  char  c, d;
  char *s0, *s1, *s2, *s3;

  s0 = s;
  s1 = s0+1;
  s2 = s1+1;
  s3 = s2+1;

  c = s1[len];
  d = s2[len];
  s0[len] = s1[len] = s2[len] = 0;

  for (i = 0; i < len; i += 4)
    *s++ = (char ) ((s0[i] << 6) | (s1[i] << 4) | (s2[i] << 2) | s3[i]);

  s1[len] = c;
  s2[len] = d;
}

// Assembly:
movslq %edi, %rax
movb 0x1(%rsi,%rax), %cl
movb 0x2(%rsi,%rax), %dl
movb $0x0, 0x2(%rsi,%rax)
movw $0x0, (%rsi,%rax)
testl %eax, %eax
jle 0x33f7
movl %edi, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
movb (%rsi,%r9), %r10b
movb 0x1(%rsi,%r9), %r11b
shlb $0x6, %r10b
shlb $0x4, %r11b
orb %r10b, %r11b
movb 0x2(%rsi,%r9), %r10b
shlb $0x2, %r10b
orb %r11b, %r10b
orb 0x3(%rsi,%r9), %r10b
movb %r10b, (%rsi,%r8)
addq $0x4, %r9
incq %r8
cmpq %rdi, %r9
jb 0x33c2
movb %cl, 0x1(%rsi,%rax)
movb %dl, 0x2(%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Uncompress_Read
void Uncompress_Read(int len, char *s)
{ int   i, tlen, byte;
  char *s0, *s1, *s2, *s3;
  char *t;

  s0 = s;
  s1 = s0+1;
  s2 = s1+1;
  s3 = s2+1;

  tlen = (len-1)/4;

  t = s+tlen;
  for (i = tlen*4; i >= 0; i -= 4)
    { byte = *t--;
      s0[i] = (char) ((byte >> 6) & 0x3);
      s1[i] = (char) ((byte >> 4) & 0x3);
      s2[i] = (char) ((byte >> 2) & 0x3);
      s3[i] = (char) (byte & 0x3);
    }
  s[len] = 4;
}

// Assembly:
cmpl $-0x2, %edi
jl 0x346e
leal -0x1(%rdi), %eax
leal 0x2(%rdi), %edx
testl %eax, %eax
cmovnsl %eax, %edx
movl %edx, %eax
sarl $0x2, %eax
andl $-0x4, %edx
cltq
addq %rsi, %rax
leaq (%rdx,%rsi), %rcx
addq $0x3, %rcx
addl $0x4, %edx
xorl %r8d, %r8d
movb (%rax,%r8), %r9b
movl %r9d, %r10d
shrb $0x6, %r10b
movb %r10b, -0x3(%rcx,%r8,4)
movl %r9d, %r10d
shrb $0x4, %r10b
andb $0x3, %r10b
movb %r10b, -0x2(%rcx,%r8,4)
movl %r9d, %r10d
shrb $0x2, %r10b
andb $0x3, %r10b
movb %r10b, -0x1(%rcx,%r8,4)
andb $0x3, %r9b
movb %r9b, (%rcx,%r8,4)
addl $-0x4, %edx
decq %r8
cmpl $0x3, %edx
jg 0x342b
movslq %edi, %rax
movb $0x4, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Lower_Read
void Lower_Read(char *s)
{ static char letter[4] = { 'a', 'c', 'g', 't' };

  for ( ; *s != 4; s++)
    *s = letter[(int) *s];
  *s = '\0';
}

// Assembly:
movb (%rdi), %al
cmpb $0x4, %al
je 0x3496
leaq 0x8b07(%rip), %rcx      # 0xbf8a
movsbq %al, %rax
movb (%rax,%rcx), %al
movb %al, (%rdi)
movb 0x1(%rdi), %al
incq %rdi
cmpb $0x4, %al
jne 0x3483
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Upper_Read
void Upper_Read(char *s)
{ static char letter[4] = { 'A', 'C', 'G', 'T' };

  for ( ; *s != 4; s++)
    *s = letter[(int) *s];
  *s = '\0';
}

// Assembly:
movb (%rdi), %al
cmpb $0x4, %al
je 0x34ba
leaq 0x8ae7(%rip), %rcx      # 0xbf8e
movsbq %al, %rax
movb (%rax,%rcx), %al
movb %al, (%rdi)
movb 0x1(%rdi), %al
incq %rdi
cmpb $0x4, %al
jne 0x34a7
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Letter_Arrow
void Letter_Arrow(char *s)
{ static char letter[4] = { '1', '2', '3', '4' };

  for ( ; *s != 4; s++)
    *s = letter[(int) *s];
  *s = '\0';
}

// Assembly:
movb (%rdi), %al
cmpb $0x4, %al
je 0x34de
leaq 0x8ac7(%rip), %rcx      # 0xbf92
movsbq %al, %rax
movb (%rax,%rcx), %al
movb %al, (%rdi)
movb 0x1(%rdi), %al
incq %rdi
cmpb $0x4, %al
jne 0x34cb
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Free_DB_Stub
void Free_DB_Stub(DAZZ_STUB *stub)
{ int i;

  if (stub == NULL)
    return;
  if (stub->fname != NULL)
    { for (i = 0; i < stub->nfiles; i++)
        free(stub->fname[i]);
      free(stub->fname-1);
    }
  if (stub->prolog != NULL)
    { for (i = 0; i < stub->nfiles; i++)
        free(stub->prolog[i]);
      free(stub->prolog-1);
    }
  if (stub->nreads != NULL)
    free(stub->nreads-1);
  free(stub->ublocks);
  free(stub->tblocks);
  free(stub);
}

// Assembly:
testq %rdi, %rdi
je 0x398d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x3926
cmpl $0x0, (%rbx)
jle 0x3919
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x3901
movq 0x10(%rbx), %rdi
addq $-0x8, %rdi
callq 0x1030
cmpq $0x0, 0x18(%rbx)
je 0x395a
cmpl $0x0, (%rbx)
jle 0x394d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x3935
movq 0x18(%rbx), %rdi
addq $-0x8, %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x396c
addq $-0x4, %rdi
callq 0x1030
movq 0x38(%rbx), %rdi
callq 0x1030
movq 0x40(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: sizeof_DB
int64 sizeof_DB(DAZZ_DB *db)
{ int64       s;
  DAZZ_TRACK *t;

  s = sizeof(DAZZ_DB)
    + sizeof(DAZZ_READ)*(db->nreads+2)
    + strlen(db->path)+1
    + (db->totlen+db->nreads+4);

  t = db->tracks;
  if (t != NULL && strcmp(t->name,".@qvs") == 0)
    { DAZZ_QV *q = (DAZZ_QV *) t;
      s += sizeof(DAZZ_QV)
         + sizeof(uint16) * db->nreads
         + q->ncodes * sizeof(QVcoding)
         + 6;
      t = t->next;
    }

  for (; t != NULL; t = t->next)
    { s += sizeof(DAZZ_TRACK)
         + strlen(t->name)+1
         + t->size * (db->nreads+1);
      if (t->data != NULL)
        { if (t->size == 8)
            s += sizeof(int)*((int64 *) t->anno)[db->nreads];
          else //  t->size == 4
            s += sizeof(int)*((int *) t->anno)[db->nreads];
        }
    }

  return (s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq 0x30(%rdi), %r15
movq 0x48(%rdi), %rdi
callq 0x10e0
addq %r15, %rax
addq 0x28(%r14), %rax
leaq (%r15,%r15,4), %rcx
leaq (%rax,%rcx,8), %rbx
addq $0xc5, %rbx
movq 0x68(%r14), %r14
testq %r14, %r14
je 0x47c7
movq 0x8(%r14), %rdi
leaq 0x6e5e(%rip), %rsi      # 0xb603
callq 0x1190
testl %eax, %eax
jne 0x47ca
movslq 0x10(%r14), %rax
leaq (%rax,%rax,8), %rax
leaq (%rbx,%r15,2), %rcx
leaq (%rcx,%rax,8), %rbx
addq $0x36, %rbx
movq (%r14), %r14
jmp 0x47ca
xorl %r14d, %r14d
testq %r14, %r14
je 0x4819
leal 0x1(%r15), %ebp
movq 0x8(%r14), %rdi
callq 0x10e0
movl 0x10(%r14), %ecx
movl %ecx, %edx
imull %ebp, %edx
movslq %edx, %rdx
addq %rbx, %rax
leaq (%rdx,%rax), %rbx
addq $0x41, %rbx
cmpq $0x0, 0x28(%r14)
je 0x4811
movq 0x18(%r14), %rax
cmpl $0x8, %ecx
jne 0x4809
movq (%rax,%r15,8), %rax
jmp 0x480d
movslq (%rax,%r15,4), %rax
leaq (%rbx,%rax,4), %rbx
movq (%r14), %r14
testq %r14, %r14
jne 0x47d3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Print_Read
void Print_Read(char *s, int width)
{ int i;

  if (s[0] < 4)
    { for (i = 0; s[i] != 4; i++)
        { if (i%width == 0 && i != 0)
            printf("\n");
          printf("%d",s[i]);
        }
      printf("\n");
    }
  else
    { for (i = 0; s[i] != '\0'; i++)
        { if (i%width == 0 && i != 0)
            printf("\n");
          printf("%c",s[i]);
        }
      printf("\n");
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x4, (%rdi)
jge 0x4ad1
leaq 0x65e0(%rip), %r15      # 0xb077
xorl %r12d, %r12d
movl %r12d, %eax
cltd
idivl %ebx
testq %r12, %r12
je 0x4ab3
testl %edx, %edx
jne 0x4ab3
movl $0xa, %edi
callq 0x1040
movsbl (%r14,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1100
cmpb $0x4, 0x1(%r14,%r12)
leaq 0x1(%r12), %r12
jne 0x4a9a
jmp 0x4b03
xorl %r15d, %r15d
movl %r15d, %eax
cltd
idivl %ebx
testq %r15, %r15
je 0x4aed
testl %edx, %edx
jne 0x4aed
movl $0xa, %edi
callq 0x1040
movsbl (%r14,%r15), %edi
callq 0x1040
cmpb $0x0, 0x1(%r14,%r15)
leaq 0x1(%r15), %r15
jne 0x4ad4
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Close_DB
void Close_DB(DAZZ_DB *db)
{ if (db->loaded)
    free(((char *) (db->bases)) - 1);
  else if (db->bases != NULL)
    fclose((FILE *) db->bases);
  if (db->reads != NULL)
    free(db->reads-1);
  free(db->path);

  Close_QVs(db);

  Close_Arrow(db);

  while (db->tracks != NULL)
    Close_Track(db,db->tracks);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x50(%rdi)
movq 0x58(%rdi), %rdi
je 0x4b30
decq %rdi
callq 0x1030
jmp 0x4b3a
testq %rdi, %rdi
je 0x4b3a
callq 0x10c0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x4b4c
addq $-0x28, %rdi
callq 0x1030
movq 0x48(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x4b7a
movq %rbx, %rdi
callq 0x4c17
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0x4b78
movq %rbx, %rdi
callq 0x4c81
jmp 0x4b65
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Close_QVs
void Close_QVs(DAZZ_DB *db)
{ DAZZ_TRACK *track;
  DAZZ_QV    *qvtrk;
  int         i;

  Active_DB = NULL;

  track = db->tracks;
  if (track != NULL && strcmp(track->name,".@qvs") == 0)
    { qvtrk = (DAZZ_QV *) track;
      for (i = 0; i < qvtrk->ncodes; i++)
        Free_QVcoding(qvtrk->coding+i);
      free(qvtrk->coding);
      free(qvtrk->table);
      fclose(qvtrk->quiva);
      db->tracks = track->next;
      free(track);
    }
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, 0xdd83(%rip) # 0x12910
movq 0x68(%rdi), %r14
testq %r14, %r14
je 0x4bad
movq %rdi, %rbx
movq 0x8(%r14), %rdi
leaq 0x6a5f(%rip), %rsi      # 0xb603
callq 0x1190
testl %eax, %eax
je 0x4bb9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x0, 0x10(%r14)
jle 0x4be2
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x18(%r14), %rdi
addq %r15, %rdi
callq 0x8c9b
incq %r12
movslq 0x10(%r14), %rax
addq $0x48, %r15
cmpq %rax, %r12
jl 0x4bc6
movq 0x18(%r14), %rdi
callq 0x1030
movq 0x20(%r14), %rdi
callq 0x1030
movq 0x28(%r14), %rdi
callq 0x10c0
movq (%r14), %rax
movq %rax, 0x68(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Close_Arrow
void Close_Arrow(DAZZ_DB *db)
{ DAZZ_ARROW *atrack;

  Arrow_DB = NULL;
  if (db->tracks != NULL && db->tracks->name == atrack_name)
    { atrack = (DAZZ_ARROW *) db->tracks;
      if (atrack->loaded)
        free(atrack->arrow);
      else
        fclose((FILE *) atrack->arrow);
      free(atrack->aoff);
      db->tracks = db->tracks->next;
      free(atrack);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, 0xdcda(%rip) # 0x12900
movq 0x68(%rdi), %r14
testq %r14, %r14
je 0x4c3c
leaq 0x7220(%rip), %rax      # 0xbe56
cmpq %rax, 0x8(%r14)
je 0x4c44
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
cmpl $0x0, 0x20(%r14)
movq 0x18(%r14), %rdi
je 0x4c59
callq 0x1030
jmp 0x4c5e
callq 0x10c0
movq 0x10(%r14), %rdi
callq 0x1030
movq 0x68(%rbx), %rax
movq (%rax), %rax
movq %rax, 0x68(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Close_Track
void Close_Track(DAZZ_DB *db, DAZZ_TRACK *track)
{ DAZZ_TRACK *record, *prev;

  prev = NULL;
  for (record = db->tracks; record != NULL; record = record->next)
    { if (track == record)
        { free(record->anno);
          free(record->alen);
          if (record->loaded)
            free(record->data);
          else
            fclose((FILE *) record->data);
          free(record->name);
          if (prev == NULL)
            db->tracks = record->next;
          else
            prev->next = record->next;
          free(record);
          return;
        }
      prev = record;
    }
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x68, %rbx
xorl %eax, %eax
movq %rbx, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x4cc9
movq %rax, %r15
movq %r14, %rax
cmpq %rsi, %r14
jne 0x4c92
movq 0x18(%r14), %rdi
callq 0x1030
movq 0x20(%r14), %rdi
callq 0x1030
cmpl $0x0, 0x30(%r14)
movq 0x28(%r14), %rdi
je 0x4ccf
callq 0x1030
jmp 0x4cd4
popq %rbx
popq %r14
popq %r15
retq
callq 0x10c0
movq 0x8(%r14), %rdi
callq 0x1030
testq %r15, %r15
movq (%r14), %rax
cmovneq %r15, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: New_Read_Buffer
char *New_Read_Buffer(DAZZ_DB *db)
{ char *read;

  read = (char *) Malloc(db->maxlen+4,"Allocating New Read Buffer");
  if (read == NULL)
    EXIT(NULL);
  return (read+1);
}

// Assembly:
pushq %rax
movslq 0x20(%rdi), %rdi
addq $0x4, %rdi
leaq 0x6930(%rip), %rsi      # 0xb637
callq 0x2b85
testq %rax, %rax
je 0x4d16
incq %rax
popq %rcx
retq
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Load_All_Reads
int Load_All_Reads(DAZZ_DB *db, int ascii)
{ FILE      *bases = (FILE *) db->bases;
  int        nreads = db->nreads;
  DAZZ_READ *reads = db->reads;
  void     (*translate)(char *s);

  char  *seq;
  int64  o, off;
  int    i, len, clen;

  if (db->loaded)
    return (0);

  seq = (char *) Malloc(db->totlen+nreads+4,"Allocating All Sequence Reads");
  if (seq == NULL)
    EXIT(1);

  *seq++ = 4;

  if (ascii == 1)
    translate = Lower_Read;
  else
    translate = Upper_Read;

  o = 0;
  for (i = 0; i < nreads; i++)
    { len = reads[i].rlen;
      off = reads[i].boff;
      if (ftello(bases) != off)
        fseeko(bases,off,SEEK_SET);
      clen = COMPRESSED_LEN(len);
      if (clen > 0)
        { if (fread(seq+o,clen,1,bases) != 1)
            { EPRINTF(EPLACE,"%s: Read of .bps file failed (Load_All_Sequences)\n",Prog_Name);
              free(seq-1);
              EXIT(1);
            }
        }
      Uncompress_Read(len,seq+o);
      if (ascii)
        translate(seq+o);
      reads[i].boff = o;
      o += (len+1);
    }
  reads[nreads].boff = o;

  fclose(bases);

  db->bases  = (void *) seq;
  db->loaded = 1;

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x0, 0x50(%rdi)
jne 0x5376
movl %esi, %ebp
movq %rdi, %rbx
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %r15
movslq 0x30(%rdi), %r12
movq 0x28(%rdi), %rax
leaq (%r12,%rax), %rdi
addq $0x4, %rdi
leaq 0x6447(%rip), %rsi      # 0xb6a1
callq 0x2b85
testq %rax, %rax
je 0x5391
movq %rbx, 0x20(%rsp)
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rsp)
movb $0x4, (%rax)
cmpl $0x1, %ebp
leaq -0x1e0f(%rip), %rcx     # 0x3476
leaq -0x1df2(%rip), %rdx     # 0x349a
cmoveq %rcx, %rdx
movq %rdx, 0x28(%rsp)
testl %r12d, %r12d
movq %r12, 0x18(%rsp)
jle 0x5349
movq %rax, 0x10(%rsp)
movl %ebp, 0x4(%rsp)
leaq (,%r12,8), %rax
leaq (%rax,%rax,4), %rax
movq %rax, 0x30(%rsp)
xorl %ebx, %ebx
xorl %ebp, %ebp
movslq 0x4(%r15,%rbx), %r12
movq 0x10(%r15,%rbx), %r13
movq %r14, %rdi
callq 0x1080
cmpq %r13, %rax
je 0x52e5
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1230
leal 0x3(%r12), %eax
sarl $0x2, %eax
testl %eax, %eax
movq 0x8(%rsp), %r13
jle 0x5311
movq %r13, %rdi
addq %rbp, %rdi
movl %eax, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x5387
addq %rbp, %r13
movl %r12d, %edi
movq %r13, %rsi
callq 0x3400
cmpl $0x0, 0x4(%rsp)
je 0x532d
movq %r13, %rdi
callq *0x28(%rsp)
movq %rbp, 0x10(%r15,%rbx)
addq %r12, %rbp
incq %rbp
addq $0x28, %rbx
cmpq %rbx, 0x30(%rsp)
jne 0x52c1
jmp 0x534b
xorl %ebp, %ebp
movq 0x18(%rsp), %rax
leaq (%rax,%rax,4), %rax
movq %rbp, 0x10(%r15,%rax,8)
movq %r14, %rdi
callq 0x10c0
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x58(%rax)
movl $0x1, 0x50(%rax)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
callq 0x16be
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Open_Arrow
int Open_Arrow(DAZZ_DB *db)
{ int64      *avector;
  DAZZ_ARROW *atrack;
  FILE       *afile;
  DAZZ_READ  *reads;
  int         i, nreads;

  if (db->tracks != NULL && db->tracks->name == atrack_name)
    return (0);
 
  if ((db->allarr & DB_ARROW) == 0)
    { EPRINTF(EPLACE,"%s: The DB is not an Arrow database (Open_Arrow)\n",Prog_Name);
      EXIT(1);
    }
  if (db->loaded)
    { EPRINTF(EPLACE,"%s: Cannot open Arrow vectors after loading all reads (Open_Arrow)\n",
                        Prog_Name);
      EXIT(1);
    }

  afile = Fopen(MyCatenate(db->path,"","",".arw"),"r");
  if (afile == NULL)
    return (-1);

  nreads  = db->nreads;
  avector = (int64 *) Malloc(sizeof(int64)*nreads,"Allocating Arrow index");
  atrack  = (DAZZ_ARROW *) Malloc(sizeof(DAZZ_ARROW),"Allocating Arrow track");
  if (avector == NULL || atrack == NULL)
    { fclose(afile);
      if (avector != NULL)
        free(avector);
      EXIT(1);
    }
  db->tracks     = (DAZZ_TRACK *) atrack;
  atrack->next   = NULL;
  atrack->name   = atrack_name;
  atrack->aoff   = avector;
  atrack->arrow  = (void *) afile;
  atrack->loaded = 0;


  reads = db->reads;
  for (i = 0; i < nreads; i++)
    avector[i] = reads[i].boff;
  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x53c0
leaq 0x6aa0(%rip), %rcx      # 0xbe56
cmpq %rcx, 0x8(%rax)
je 0x548a
testb $0x2, 0xc(%rbx)
je 0x549f
cmpl $0x0, 0x50(%rbx)
jne 0x54a4
movq 0x48(%rbx), %rdi
leaq 0x657b(%rip), %rdx      # 0xb95a
leaq 0x6382(%rip), %rcx      # 0xb768
movq %rdx, %rsi
callq 0x4215
leaq 0x695c(%rip), %rsi      # 0xbd51
movq %rax, %rdi
callq 0x2ca1
testq %rax, %rax
je 0x548e
movq %rax, %r15
movslq 0x30(%rbx), %r12
leaq (,%r12,8), %rdi
leaq 0x6351(%rip), %rsi      # 0xb76d
callq 0x2b85
movq %rax, %r14
leaq 0x6359(%rip), %rsi      # 0xb784
movl $0x28, %edi
callq 0x2b85
testq %r14, %r14
je 0x54a9
testq %rax, %rax
je 0x54a9
movq %rax, 0x68(%rbx)
movq $0x0, (%rax)
leaq 0x6a05(%rip), %rcx      # 0xbe56
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x0, 0x20(%rax)
testl %r12d, %r12d
jle 0x548a
movq 0x60(%rbx), %rcx
addq $0x10, %rcx
xorl %eax, %eax
xorl %edx, %edx
movq (%rcx), %rsi
movq %rsi, (%r14,%rdx,8)
incq %rdx
addq $0x28, %rcx
cmpq %rdx, %r12
jne 0x5475
jmp 0x5493
xorl %eax, %eax
jmp 0x5493
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1719
callq 0x16f1
movq %r15, %rdi
callq 0x10c0
testq %r14, %r14
je 0x54be
movq %r14, %rdi
callq 0x1030
movl $0x1, %edi
callq 0x1270