LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpl $0x0, 0x3ced(%rip)      # 0x70c4
jne 0x33fd
movq 0x3c18(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x1415(%rip), %rsi      # 0x47ff
movb $0x0, %al
callq 0x10c0
movl $0x0, -0x4(%rbp)
jmp 0x3512
cmpl $0x0, 0x3cc4(%rip)      # 0x70c8
jne 0x342a
movq 0x3beb(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x13f9(%rip), %rsi      # 0x4810
movb $0x0, %al
callq 0x10c0
movl $0x0, -0x4(%rbp)
jmp 0x3512
cmpl $0x0, 0x3c9b(%rip)      # 0x70cc
jne 0x3457
movq 0x3bbe(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x13e8(%rip), %rsi      # 0x482c
movb $0x0, %al
callq 0x10c0
movl $0x0, -0x4(%rbp)
jmp 0x3512
movl 0x3c5f(%rip), %eax      # 0x70bc
shll $0x9, %eax
movl %eax, -0x1c(%rbp)
movl 0x3c5b(%rip), %eax      # 0x70c4
imull 0x3c58(%rip), %eax      # 0x70c8
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
cmpl $0x0, %eax
je 0x349f
leaq 0xb73(%rip), %rdi       # 0x4004
callq 0x1110
movl $0x0, -0x4(%rbp)
jmp 0x3512
movq -0x18(%rbp), %rdi
movl 0x3c1b(%rip), %eax      # 0x70c4
movl %eax, %esi
movl 0x3c1b(%rip), %eax      # 0x70cc
movl %eax, %edx
movq -0x10(%rbp), %rcx
callq 0x1130
movl 0x3c0a(%rip), %ecx      # 0x70cc
cmpq %rcx, %rax
je 0x34e8
movq 0x3b2a(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x13bb(%rip), %rsi      # 0x4893
movb $0x0, %al
callq 0x10c0
movl $0x0, -0x4(%rbp)
jmp 0x3512
movq -0x10(%rbp), %rdi
callq 0x10e0
cmpl $0x0, %eax
je 0x350b
leaq 0x13af(%rip), %rdi      # 0x48ac
callq 0x1110
movl $0x0, -0x4(%rbp)
jmp 0x3512
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x354c
movl $0x0, -0x4(%rbp)
jmp 0x35f9
leaq 0x1360(%rip), %rdi      # 0x48b3
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x21f0
cmpl $0x0, %eax
jne 0x357a
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x35f9
leaq 0x1349(%rip), %rdi      # 0x48ca
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
movl 0x3b3e(%rip), %eax      # 0x70d0
imull 0x3b43(%rip), %eax      # 0x70dc
movl %eax, %eax
addq %rax, %rdi
callq 0x21f0
leaq 0x1335(%rip), %rdi      # 0x48df
movb $0x0, %al
callq 0x1080
movl 0x3b1d(%rip), %eax      # 0x70d4
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x35e9
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
imull 0x3b0e(%rip), %eax      # 0x70dc
movl %eax, %eax
addq %rax, %rdi
callq 0x21f0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x3610
movl %eax, -0x1c(%rbp)
jmp 0x35ba
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/miniupnp[P]hfsplustools/src/hfscommon.c
// Function: next_node
static uint32_t next_node(unsigned char * catalog, uint32_t node)
{
	const unsigned char * p;
	if(node == 0)
		return 0;
	p = catalog + node * catalog_node_size;
	return readu32(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x362e
movl $0x0, -0x4(%rbp)
jmp 0x3651
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
imull 0x3aa0(%rip), %ecx      # 0x70dc
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1af0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1ab0
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x20(%rbp), %ecx
movzwl -0x1a(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x25(%rbp)
jge 0x3b0b
movl -0x24(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x3b17
jmp 0x3b9c
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3b30
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x20, %eax
jge 0x3b66
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %r8d
movl $0x7, %esi
leaq 0xf31(%rip), %rdx       # 0x4a88
movb $0x0, %al
callq 0x1090
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3b82
movq -0x18(%rbp), %rax
movb 0x1(%rax), %dl
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3aea
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
leaq 0xcc4c(%rip), %rsi      # 0xe004
callq 0x22c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1100
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x10f66(%rip), %rdi     # 0x12370
movl $0x2711, %esi           # imm = 0x2711
callq 0x1160
cmpq $0x0, %rax
jne 0x1463
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1190
cmpl $0x0, %eax
je 0x1437
movl $0x1, -0x4(%rbp)
jmp 0x1551
movq 0x10bba(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
leaq 0x13640(%rip), %rax     # 0x14a88
movq (%rax), %rdx
leaq 0xcbcb(%rip), %rsi      # 0xe01d
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
leaq 0x10f06(%rip), %rdi     # 0x12370
movl $0xa, %esi
callq 0x1130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x14b9
movq 0x10b73(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
leaq 0x135f9(%rip), %rax     # 0x14a88
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0xcb9d(%rip), %rsi      # 0xe03d
movl $0x2710, %r8d           # imm = 0x2710
movb $0x0, %al
callq 0x1180
movl $0x1, -0x4(%rbp)
jmp 0x1551
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdx
addq $0xc, %rdx
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %r8
addq $0x14, %r8
leaq 0x10e91(%rip), %rdi     # 0x12370
leaq 0xcb8a(%rip), %rsi      # 0xe070
movb $0x0, %al
callq 0x11f0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x1503
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
jmp 0x153d
cmpl $0x3, -0x1c(%rbp)
je 0x153b
movq 0x10ae8(%rip), %rax     # 0x11ff8
movq (%rax), %rdi
leaq 0x1356e(%rip), %rax     # 0x14a88
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0xcb4f(%rip), %rsi      # 0xe07a
movb $0x0, %al
callq 0x1180
movl $0x1, -0x4(%rbp)
jmp 0x1551
jmp 0x153d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x22b7
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0x2277
cmpl $0x0, -0x10(%rbp)
jne 0x2275
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x22a7
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x228e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x22a5
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0x22a3
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x22a5
jmp 0x22a7
jmp 0x22a9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x224e
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2330
cmpq $0x0, -0x10(%rbp)
jne 0x230b
movq 0xfd07(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x1278d(%rip), %rdx     # 0x14a88
leaq 0xbf4e(%rip), %rsi      # 0xe250
movb $0x0, %al
callq 0x1180
jmp 0x232e
movq 0xfce6(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x1276c(%rip), %rdx     # 0x14a88
movq -0x10(%rbp), %rcx
leaq 0xbf3c(%rip), %rsi      # 0xe263
movb $0x0, %al
callq 0x1180
jmp 0x2330
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jg 0x2363
movq $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1200
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x23c7
cmpq $0x0, -0x18(%rbp)
jne 0x23a2
movq 0xfc70(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x126f6(%rip), %rdx     # 0x14a88
leaq 0xbeb7(%rip), %rsi      # 0xe250
movb $0x0, %al
callq 0x1180
jmp 0x23c5
movq 0xfc4f(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x126d5(%rip), %rdx     # 0x14a88
movq -0x18(%rbp), %rcx
leaq 0xbea5(%rip), %rsi      # 0xe263
movb $0x0, %al
callq 0x1180
jmp 0x23c7
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2401
movq $0x0, -0x8(%rbp)
jmp 0x2469
movq -0x10(%rbp), %rdi
callq 0x1280
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2461
cmpq $0x0, -0x18(%rbp)
jne 0x243c
movq 0xfbd6(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x1265c(%rip), %rdx     # 0x14a88
leaq 0xbe1d(%rip), %rsi      # 0xe250
movb $0x0, %al
callq 0x1180
jmp 0x245f
movq 0xfbb5(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x1263b(%rip), %rdx     # 0x14a88
movq -0x18(%rbp), %rcx
leaq 0xbe0b(%rip), %rsi      # 0xe263
movb $0x0, %al
callq 0x1180
jmp 0x2461
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x249e
cmpq $0x0, -0x18(%rbp)
jne 0x24a8
movq $0x0, -0x8(%rbp)
jmp 0x24ee
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1230
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x24e6
movq 0xfb32(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x125b8(%rip), %rdx     # 0x14a88
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0xbd9c(%rip), %rsi      # 0xe27b
movb $0x0, %al
callq 0x1180
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x251d
movq $0x0, -0x8(%rbp)
jmp 0x2578
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x1240
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2559
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0xbd51(%rip), %rsi      # 0xe298
callq 0x23e0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movb $0x2f, (%rax)
jmp 0x2570
leaq 0xbf8e(%rip), %rdi      # 0xe4ee
leaq 0xbd46(%rip), %rsi      # 0xe2ad
callq 0x23e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x25b4
movq $0x0, -0x8(%rbp)
jmp 0x26c3
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x1240
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x25d7
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x25e3
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2631
movq -0x28(%rbp), %rdi
movl $0x2e, %esi
callq 0x10e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x260a
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
leaq 0xbcb0(%rip), %rsi      # 0xe2c5
callq 0x23e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x262c
movq -0x30(%rbp), %rax
movb $0x2e, (%rax)
jmp 0x26bb
movq -0x28(%rbp), %rdi
callq 0x10d0
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10d0
movq %rax, %rcx
movslq -0x34(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x26a5
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
cmpl $0x0, %eax
jne 0x26a5
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
leaq 0xbc3c(%rip), %rsi      # 0xe2c5
callq 0x23e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %dl
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x26b9
movq -0x28(%rbp), %rdi
leaq 0xbc2a(%rip), %rsi      # 0xe2da
callq 0x23e0
movq %rax, -0x20(%rbp)
jmp 0x26bb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2704
cmpq $0x0, -0x20(%rbp)
je 0x2704
cmpq $0x0, -0x18(%rbp)
je 0x2704
cmpq $0x0, -0x28(%rbp)
jne 0x2711
movq $0x0, -0x8(%rbp)
jmp 0x2810
movq -0x10(%rbp), %rdi
callq 0x10d0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10d0
movq %rax, %rcx
movslq -0x2c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10d0
movq %rax, %rcx
movslq -0x2c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10d0
movq %rax, %rcx
movslq -0x2c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0xfa38(%rip), %eax      # 0x121a0
jle 0x27e0
cvtsi2sdl -0x2c(%rbp), %xmm1
movsd 0xbad1(%rip), %xmm0     # 0xe248
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x64, %eax
movl %eax, 0xfa18(%rip)      # 0x121a0
movq 0x12301(%rip), %rdi     # 0x14a90
movl 0xfa0b(%rip), %eax      # 0x121a0
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1200
movq %rax, 0x122e9(%rip)     # 0x14a90
cmpq $0x0, 0x122e1(%rip)     # 0x14a90
jne 0x27de
movq 0xf840(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x122c6(%rip), %rdx     # 0x14a88
movq -0x20(%rbp), %rcx
leaq 0xbb1d(%rip), %rsi      # 0xe2ea
movb $0x0, %al
callq 0x1180
movq $0x0, -0x8(%rbp)
jmp 0x2810
jmp 0x27e0
movq 0x122a9(%rip), %rdi     # 0x14a90
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq 0xbb19(%rip), %rsi      # 0xe317
movb $0x0, %al
callq 0x1250
movq 0x12284(%rip), %rax     # 0x14a90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2841
cmpq $0x0, -0x20(%rbp)
jne 0x284e
movq $0x0, -0x8(%rbp)
jmp 0x291f
movq -0x10(%rbp), %rdi
callq 0x10d0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10d0
movq %rax, %rcx
addq $0x28, %rcx
movslq -0x24(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0xf927(%rip), %eax      # 0x121a4
jle 0x28f4
cvtsi2sdl -0x24(%rbp), %xmm1
movsd 0xb9bc(%rip), %xmm0     # 0xe248
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addl $0x64, %eax
movl %eax, 0xf907(%rip)      # 0x121a4
movq 0x121f4(%rip), %rdi     # 0x14a98
movl 0xf8fa(%rip), %eax      # 0x121a4
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1200
movq %rax, 0x121dc(%rip)     # 0x14a98
cmpq $0x0, 0x121d4(%rip)     # 0x14a98
jne 0x28f2
movq 0xf72b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0x121b1(%rip), %rdx     # 0x14a88
movl -0x14(%rbp), %ecx
leaq 0xba3f(%rip), %rsi      # 0xe320
movb $0x0, %al
callq 0x1180
movq $0x0, -0x8(%rbp)
jmp 0x291f
jmp 0x28f4
movq 0x1219d(%rip), %rdi     # 0x14a98
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq 0xba44(%rip), %rsi      # 0xe351
movb $0x0, %al
callq 0x1250
movq 0x1217d(%rip), %rax     # 0x14a98
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x1, -0x8(%rbp)
jl 0x2e03
movq -0x8(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ddf
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movq -0x30(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x16(%rbp)
movq -0x30(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2ef3
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
shll $0x6, %eax
movq -0x28(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x38(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e8e
movb -0x15(%rbp), %dl
movq -0x28(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x16(%rbp), %dl
movq -0x30(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x18(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2ffb
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x48(%rbp)
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x6, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
sarl $0x4, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
sarl $0x2, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
andl $0x3, %eax
movb %al, %dl
movq -0x40(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f80
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x4, (%rax,%rcx)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4, %eax
je 0x304c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0xf173(%rip), %rax      # 0x121a8
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3018
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4, %eax
je 0x309c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0xf127(%rip), %rax      # 0x121ac
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3068
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4, %eax
je 0x30ec
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0xf0db(%rip), %rax      # 0x121b0
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x30b8
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DB.c
// Function: Number_Read
void Number_Read(char *s)
{ static char number[128] =
    { 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 1, 0, 0, 0, 2,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 3, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 1, 0, 0, 0, 2,
      0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 3, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0,
    };

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x313c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0xf09b(%rip), %rax      # 0x121c0
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3108
movq -0x8(%rbp), %rax
movb $0x4, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DB.c
// Function: Number_Arrow
void Number_Arrow(char *s)
{ static char arrow[128] =
    { 3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 0, 1, 2, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 2,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
      3, 3, 3, 3, 3, 3, 3, 3,
    };

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x318c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movslq %eax, %rcx
leaq 0xf0cb(%rip), %rax      # 0x12240
movb (%rax,%rcx), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3158
movq -0x8(%rbp), %rax
movb $0x4, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3748
jmp 0x3823
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3796
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3785
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x375a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $-0x8, %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x37e4
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x37d3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x37a8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
addq $-0x8, %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3800
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $-0x4, %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
addl $0x2, %eax
cltq
imulq $0x28, %rax, %rax
addq $0x70, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x10d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x8(%rbp), %rdx
movslq 0x30(%rdx), %rdx
addq %rdx, %rcx
addq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4ee6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x9764(%rip), %rsi      # 0xe603
callq 0x1170
cmpl $0x0, %eax
jne 0x4ee6
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq 0x30(%rax), %rax
shlq %rax
addq $0x30, %rax
movq -0x20(%rbp), %rcx
movslq 0x10(%rcx), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
addq $0x6, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4ee8
cmpq $0x0, -0x18(%rbp)
je 0x4f95
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10d0
addq $0x40, %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
movq -0x8(%rbp), %rdx
movl 0x30(%rdx), %edx
addl $0x1, %edx
imull %edx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4f83
movq -0x18(%rbp), %rax
cmpl $0x8, 0x10(%rax)
jne 0x4f61
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4f81
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x30(%rcx), %rcx
movslq (%rax,%rcx,4), %rax
shlq $0x2, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4f83
jmp 0x4f85
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4ee8
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4, %eax
jge 0x5348
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x4, %eax
je 0x5338
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
cmpl $0x0, %edx
jne 0x5313
cmpl $0x0, -0x10(%rbp)
je 0x5313
leaq 0x9650(%rip), %rdi      # 0xe95c
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x8d51(%rip), %rdi      # 0xe077
movb $0x0, %al
callq 0x10f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x52e2
leaq 0x961d(%rip), %rdi      # 0xe95c
movb $0x0, %al
callq 0x10f0
jmp 0x53b3
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x53a5
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
cmpl $0x0, %edx
jne 0x5380
cmpl $0x0, -0x10(%rbp)
je 0x5380
leaq 0x95e3(%rip), %rdi      # 0xe95c
movb $0x0, %al
callq 0x10f0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x92a4(%rip), %rdi      # 0xe637
movb $0x0, %al
callq 0x10f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x534f
leaq 0x95b0(%rip), %rdi      # 0xe95c
movb $0x0, %al
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x50(%rax)
je 0x53e9
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
addq $-0x1, %rdi
callq 0x1030
jmp 0x5403
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x5401
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x10b0
jmp 0x5403
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x541f
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
addq $-0x28, %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x5470
movq -0x8(%rbp), %rdi
callq 0x5540
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x545c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x55e0
jmp 0x543e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, 0xf629(%rip) # 0x14ab0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5534
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x9156(%rip), %rsi      # 0xe603
callq 0x1170
cmpl $0x0, %eax
jne 0x5534
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x54f5
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rdi
callq 0xb8c0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x54c6
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10b0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, 0xf549(%rip) # 0x14aa0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x55d2
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq 0x8(%rax), %rax
cmpq 0xcdcb(%rip), %rax      # 0x12340
jne 0x55d2
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x559c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
jmp 0x55a9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x56af
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x5697
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x564c
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
jmp 0x5659
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10b0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
cmpq $0x0, -0x20(%rbp)
jne 0x567e
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
jmp 0x568c
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x56b1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5604
jmp 0x56b1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addl $0x4, %eax
movslq %eax, %rdi
leaq 0x8f5a(%rip), %rsi      # 0xe63a
callq 0x22c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x56fa
movl $0x1, %edi
callq 0x1260
movq -0x10(%rbp), %rax
addq $0x1, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DB.c
// Function: New_Track_Buffer
void *New_Track_Buffer(DAZZ_TRACK *track)
{ void *data;

  data = (void *) Malloc(track->dmax,"Allocating New Track Data Buffer");
  if (data == NULL)
    EXIT(NULL);
  return (data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
leaq 0x73fc(%rip), %rsi      # 0xe9c7
callq 0x22c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x75e5
movl $0x1, %edi
callq 0x1260
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop