LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
leal -0x1(%rdi), %eax
pushq $0x4
popq %rcx
cltd
idivl %ecx
cltq
leaq (%rsi,%rax), %rcx
shll $0x2, %eax
testl %eax, %eax
js 0x238d
movb (%rcx), %dl
decq %rcx
movl %edx, %r8d
shrb $0x6, %r8b
movl %eax, %r9d
movb %r8b, (%rsi,%r9)
movl %edx, %r8d
shrb $0x4, %r8b
andb $0x3, %r8b
movb %r8b, 0x1(%rsi,%r9)
movl %edx, %r8d
shrb $0x2, %r8b
andb $0x3, %r8b
movb %r8b, 0x2(%rsi,%r9)
andb $0x3, %dl
movb %dl, 0x3(%rsi,%r9)
addl $-0x4, %eax
jmp 0x2349
movslq %edi, %rax
movb $0x4, (%rsi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x7bee(%rip), %rax      # 0x9f8a
movsbq (%rdi), %rcx
cmpq $0x4, %rcx
je 0x23b0
movb (%rcx,%rax), %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x239c
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x7bd3(%rip), %rax      # 0x9f8e
movsbq (%rdi), %rcx
cmpq $0x4, %rcx
je 0x23cf
movb (%rcx,%rax), %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x23bb
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
leaq 0x7bb8(%rip), %rax      # 0x9f92
movsbq (%rdi), %rcx
cmpq $0x4, %rcx
je 0x23ee
movb (%rcx,%rax), %cl
movb %cl, (%rdi)
incq %rdi
jmp 0x23da
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28a3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x2843
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jge 0x283a
movq (%rdi,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x2820
addq $-0x8, %rdi
callq 0x1030
cmpq $0x0, 0x18(%rbx)
je 0x2870
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x18(%rbx), %rdi
cmpq %rax, %r14
jge 0x2867
movq (%rdi,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x284d
addq $-0x8, %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2882
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_O2/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
imulq $0x28, %r15, %rcx
leaq (%rcx,%rax), %rbx
addq $0xc5, %rbx
movq 0x68(%r14), %r14
testq %r14, %r14
je 0x378a
movq 0x8(%r14), %rdi
leaq 0x5e9b(%rip), %rsi      # 0x9603
callq 0x1190
testl %eax, %eax
jne 0x378d
movslq 0x10(%r14), %rax
imulq $0x48, %rax, %rax
leaq (%rbx,%r15,2), %rcx
leaq (%rax,%rcx), %rbx
addq $0x36, %rbx
movq (%r14), %r14
jmp 0x378d
xorl %r14d, %r14d
leal 0x1(%r15), %ebp
testq %r14, %r14
je 0x37d8
movq 0x8(%r14), %rdi
callq 0x10e0
movl 0x10(%r14), %ecx
movl %ecx, %edx
imull %ebp, %edx
movslq %edx, %rdx
addq %rax, %rbx
addq %rdx, %rbx
addq $0x41, %rbx
cmpq $0x0, 0x28(%r14)
je 0x37d3
movq 0x18(%r14), %rax
cmpl $0x8, %ecx
jne 0x37cb
movq (%rax,%r15,8), %rax
jmp 0x37cf
movslq (%rax,%r15,4), %rax
leaq (%rbx,%rax,4), %rbx
movq (%r14), %r14
jmp 0x3791
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %cl
cmpb $0x4, %cl
jge 0x3a69
pushq $0xa
popq %rbp
leaq 0x5647(%rip), %r15      # 0x9077
xorl %r12d, %r12d
cmpb $0x4, %cl
je 0x3a9f
movl %r12d, %eax
cltd
idivl %ebx
testq %r12, %r12
je 0x3a52
testl %edx, %edx
jne 0x3a52
movl %ebp, %edi
callq 0x1040
movb (%r14,%r12), %cl
movsbl %cl, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1100
movb 0x1(%r14,%r12), %cl
incq %r12
jmp 0x3a33
xorl %r15d, %r15d
pushq $0xa
popq %rbp
testb %cl, %cl
je 0x3a9f
movl %r15d, %eax
cltd
idivl %ebx
testq %r15, %r15
je 0x3a8d
testl %edx, %edx
jne 0x3a8d
movl %ebp, %edi
callq 0x1040
movb (%r14,%r15), %cl
movsbl %cl, %edi
callq 0x1040
movb 0x1(%r14,%r15), %cl
incq %r15
jmp 0x3a6f
pushq $0xa
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x3ac7
decq %rdi
callq 0x1030
jmp 0x3ad1
testq %rdi, %rdi
je 0x3ad1
callq 0x10c0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x3ae3
addq $-0x28, %rdi
callq 0x1030
movq 0x48(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x3b11
movq %rbx, %rdi
callq 0x3ba2
movq 0x68(%rbx), %rsi
testq %rsi, %rsi
je 0x3b0f
movq %rbx, %rdi
callq 0x3c08
jmp 0x3afc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0xcdef(%rip)      # 0x10910
movq 0x68(%rdi), %rbx
testq %rbx, %rbx
je 0x3b41
movq %rdi, %r14
movq 0x8(%rbx), %rdi
leaq 0x5acb(%rip), %rsi      # 0x9603
callq 0x1190
testl %eax, %eax
je 0x3b4d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x10(%rbx), %rax
movq 0x18(%rbx), %rdi
cmpq %rax, %r12
jge 0x3b71
addq %r15, %rdi
callq 0x7b3e
incq %r12
addq $0x48, %r15
jmp 0x3b53
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x1030
movq 0x28(%rbx), %rdi
callq 0x10c0
movq (%rbx), %rax
movq %rax, 0x68(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0xcd52(%rip)      # 0x10900
movq 0x68(%rdi), %rbx
testq %rbx, %rbx
je 0x3bc4
leaq 0x6298(%rip), %rax      # 0x9e56
cmpq %rax, 0x8(%rbx)
je 0x3bcc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %r14
cmpl $0x0, 0x20(%rbx)
movq 0x18(%rbx), %rdi
je 0x3be0
callq 0x1030
jmp 0x3be5
callq 0x10c0
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x68(%r14), %rax
movq (%rax), %rax
movq %rax, 0x68(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x3c50
movq %rax, %r15
movq %r14, %rax
cmpq %rsi, %r14
jne 0x3c19
movq 0x18(%r14), %rdi
callq 0x1030
movq 0x20(%r14), %rdi
callq 0x1030
cmpl $0x0, 0x30(%r14)
movq 0x28(%r14), %rdi
je 0x3c56
callq 0x1030
jmp 0x3c5b
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_O2/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 0x59a9(%rip), %rsi      # 0x9637
callq 0x1bad
testq %rax, %rax
je 0x3c9d
incq %rax
popq %rcx
retq
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/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 0x4139
movl %esi, %ebp
movq 0x58(%rdi), %r14
movq 0x60(%rdi), %rbx
movslq 0x30(%rdi), %r15
movq %rdi, 0x20(%rsp)
movq 0x28(%rdi), %rax
leaq (%r15,%rax), %rdi
addq $0x4, %rdi
leaq 0x566d(%rip), %rsi      # 0x96a1
callq 0x1bad
testq %rax, %rax
je 0x4173
movq %rax, %rcx
incq %rcx
movq %rcx, 0x8(%rsp)
movl %ebp, 0x4(%rsp)
cmpl $0x1, %ebp
leaq -0x1cc6(%rip), %rcx     # 0x2395
leaq -0x1cae(%rip), %rdx     # 0x23b4
cmoveq %rcx, %rdx
movq %rdx, 0x28(%rsp)
xorl %ebp, %ebp
testl %r15d, %r15d
movl $0x0, %ecx
movq %r15, 0x18(%rsp)
cmovgl %r15d, %ecx
movq %rax, 0x10(%rsp)
movb $0x4, (%rax)
imulq $0x28, %rcx, %rax
movq %rax, 0x30(%rsp)
xorl %r12d, %r12d
cmpq %rbp, 0x30(%rsp)
je 0x4111
movslq 0x4(%rbx,%rbp), %r13
movq 0x10(%rbx,%rbp), %r15
movq %r14, %rdi
callq 0x1080
cmpq %r15, %rax
je 0x40bd
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1230
leal 0x3(%r13), %eax
sarl $0x2, %eax
testl %eax, %eax
movq 0x8(%rsp), %r15
jle 0x40e4
leaq (%r15,%r12), %rdi
movl %eax, %esi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x414a
addq %r12, %r15
movl %r13d, %edi
movq %r15, %rsi
callq 0x2337
cmpl $0x0, 0x4(%rsp)
je 0x4100
movq %r15, %rdi
callq *0x28(%rsp)
movq %r12, 0x10(%rbx,%rbp)
addq %r13, %r12
incq %r12
addq $0x28, %rbp
jmp 0x4092
imulq $0x28, 0x18(%rsp), %rax
movq %r12, 0x10(%rbx,%rax)
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 0x9ea7(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc78d(%rip), %rdx      # 0x108e8
leaq 0x555d(%rip), %rsi      # 0x96bf
xorl %eax, %eax
callq 0x11a0
movq 0x10(%rsp), %rdi
callq 0x1030
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/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 0x41a0
leaq 0x5cc0(%rip), %rcx      # 0x9e56
cmpq %rcx, 0x8(%rax)
je 0x4271
testb $0x2, 0xc(%rbx)
je 0x427f
cmpl $0x0, 0x50(%rbx)
jne 0x4299
movq 0x48(%rbx), %rdi
leaq 0x579b(%rip), %rdx      # 0x995a
leaq 0x55a2(%rip), %rcx      # 0x9768
movq %rdx, %rsi
callq 0x31cf
leaq 0x5b7c(%rip), %rsi      # 0x9d51
movq %rax, %rdi
callq 0x1ccb
testq %rax, %rax
je 0x426c
movq %rax, %r15
movslq 0x30(%rbx), %r12
leaq (,%r12,8), %rdi
leaq 0x5571(%rip), %rsi      # 0x976d
callq 0x1bad
movq %rax, %r14
leaq 0x5579(%rip), %rsi      # 0x9784
pushq $0x28
popq %rdi
callq 0x1bad
testq %r14, %r14
je 0x42ba
testq %rax, %rax
je 0x42ba
movq %rax, 0x68(%rbx)
andq $0x0, (%rax)
leaq 0x5c22(%rip), %rcx      # 0x9e56
movq %rcx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
andl $0x0, 0x20(%rax)
movq 0x60(%rbx), %rcx
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
addq $0x10, %rcx
xorl %edx, %edx
cmpq %rdx, %r12
je 0x4273
movq (%rcx), %rsi
movq %rsi, (%r14,%rdx,8)
incq %rdx
addq $0x28, %rcx
jmp 0x4257
pushq $-0x1
popq %rax
jmp 0x4273
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9d72(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc658(%rip), %rdx      # 0x108e8
leaq 0x545b(%rip), %rsi      # 0x96f2
jmp 0x42b1
movq 0x9d58(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc63e(%rip), %rdx      # 0x108e8
leaq 0x5473(%rip), %rsi      # 0x9724
xorl %eax, %eax
callq 0x11a0
jmp 0x42ca
movq %r15, %rdi
callq 0x10c0
movq %r14, %rdi
callq 0x1030
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Load_Arrow
int Load_Arrow(DAZZ_DB *db, int i, char *arrow, int ascii)
{ FILE      *afile;
  int64      off;
  int        len, clen;

  if (db != Arrow_DB)
    { if (db->tracks == NULL || db->tracks->name != atrack_name)
        { EPRINTF(EPLACE,"%s: Arrow data is not available (Load_Arrow)\n",Prog_Name);
          EXIT(1);
        }
      Arrow_Ptr = (DAZZ_ARROW *) db->tracks;
      Arrow_DB  = db;
    }

  if (i < 0 || i >= db->nreads)
    { EPRINTF(EPLACE,"%s: Index out of bounds (Load_Arrow)\n",Prog_Name);
      EXIT(1);
    }

  afile = (FILE *) Arrow_Ptr->arrow;
  off   = Arrow_Ptr->aoff[i];
  len   = db->reads[i].rlen;

  if (ftello(afile) != off)
    fseeko(afile,off,SEEK_SET);
  clen = COMPRESSED_LEN(len);
  if (clen > 0)
    { if (fread(arrow,clen,1,afile) != 1)
        { EPRINTF(EPLACE,"%s: Failed read of .arw file (Load_Arrow)\n",Prog_Name);
          EXIT(1);
        }
    }
  Uncompress_Read(len,arrow);
  if (ascii == 1)
    { Letter_Arrow(arrow);
      arrow[-1] = '\0';
    }
  else
    arrow[-1] = 4;
  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
cmpq %rdi, 0xc61a(%rip)      # 0x10900
je 0x4314
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x43c6
leaq 0x5b5a(%rip), %rcx      # 0x9e56
cmpq %rcx, 0x8(%rax)
jne 0x43c6
movq %rax, 0xc5fb(%rip)      # 0x10908
movq %rdi, 0xc5ec(%rip)      # 0x10900
testl %esi, %esi
js 0x43ac
cmpl %esi, 0x30(%rdi)
jle 0x43ac
movq 0xc5dc(%rip), %rax      # 0x10908
movq 0x10(%rax), %rcx
movq 0x18(%rax), %r15
movl %esi, %eax
movq (%rcx,%rax,8), %r12
movq 0x60(%rdi), %rcx
imulq $0x28, %rax, %rax
movl 0x4(%rcx,%rax), %r14d
movq %r15, %rdi
callq 0x1080
cmpq %r12, %rax
je 0x4361
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1230
leal 0x3(%r14), %eax
sarl $0x2, %eax
testl %eax, %eax
jle 0x4382
movl %eax, %esi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x43e0
movl %r14d, %edi
movq %rbx, %rsi
callq 0x2337
movb $0x4, %al
cmpl $0x1, %ebp
jne 0x439e
movq %rbx, %rdi
callq 0x23d3
xorl %eax, %eax
movb %al, -0x1(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x9c45(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc52b(%rip), %rdx      # 0x108e8
leaq 0x5405(%rip), %rsi      # 0x97c9
jmp 0x43f8
movq 0x9c2b(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc511(%rip), %rdx      # 0x108e8
leaq 0x53bd(%rip), %rsi      # 0x979b
jmp 0x43f8
movq 0x9c11(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc4f7(%rip), %rdx      # 0x108e8
leaq 0x53f7(%rip), %rsi      # 0x97ef
xorl %eax, %eax
callq 0x11a0
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Check_Track
int Check_Track(DAZZ_DB *db, char *track, int *kind)
{ FILE       *afile;
  int         tracklen, size, ispart;
  int         ureads, treads;

  afile = NULL;
  if (db->part > 0)
    { afile  = fopen(MyCatenate(db->path,MyNumbered_Suffix(".",db->part,"."),track,".anno"),"r");
      ispart = 1;
    }
  if (afile == NULL)
    { afile  = fopen(MyCatenate(db->path,".",track,".anno"),"r");
      ispart = 0;
    }
  if (afile == NULL)
    return (-2);

  if (fread(&tracklen,sizeof(int),1,afile) != 1)
    { EPRINTF(EPLACE,"%s: track files for %s are corrupted\n",Prog_Name,track);
      fclose(afile);
      EXIT(-3);
    }
  if (fread(&size,sizeof(int),1,afile) != 1)
    { EPRINTF(EPLACE,"%s: track files for %s are corrupted\n",Prog_Name,track);
      fclose(afile);
      EXIT(-3);
    }

  if (size == 0)
    *kind = MASK_TRACK;
  else if (size > 0)
    *kind = CUSTOM_TRACK;
  else
    { EPRINTF(EPLACE,"%s: track files for %s are corrupted\n",Prog_Name,track);
      fclose(afile);
      EXIT(-3);
    }
  
  fclose(afile);

  if (ispart)
    { ureads = ((int *) (db->reads))[-1];
      treads = ((int *) (db->reads))[-2];
    }
  else
    { ureads = db->ureads;
      treads = db->treads;
    }

  if (tracklen == ureads)
    return (0);
  else if (tracklen == treads)
    return (1);
  else
    return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movl 0x38(%rdi), %esi
testl %esi, %esi
jle 0x4649
movq 0x48(%r14), %r15
leaq 0x4edd(%rip), %rdi      # 0x94ee
movq %rdi, %rdx
callq 0x4744
leaq 0x5243(%rip), %rcx      # 0x9863
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x31cf
leaq 0x571c(%rip), %rsi      # 0x9d51
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
je 0x4649
movq %rax, %r15
xorl %ebp, %ebp
jmp 0x4681
movq 0x48(%r14), %rdi
leaq 0x4e9a(%rip), %rsi      # 0x94ee
leaq 0x5208(%rip), %rcx      # 0x9863
movq %rbx, %rdx
callq 0x31cf
leaq 0x56e7(%rip), %rsi      # 0x9d51
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
je 0x4734
movq %rax, %r15
movb $0x1, %bpl
leaq 0xc(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x46c1
leaq 0x8(%rsp), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x46c1
movl 0x8(%rsp), %ecx
testl %ecx, %ecx
je 0x46f3
xorl %eax, %eax
testl %ecx, %ecx
jg 0x46f6
movq 0x9930(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xc216(%rip), %rdx      # 0x108e8
leaq 0x5190(%rip), %rsi      # 0x9869
movq %rbx, %rcx
xorl %eax, %eax
callq 0x11a0
movq %r15, %rdi
callq 0x10c0
pushq $0x1
popq %rdi
callq 0x1270
pushq $0x1
popq %rax
movl %eax, (%r12)
movq %r15, %rdi
callq 0x10c0
testb %bpl, %bpl
je 0x470d
leaq 0x4(%r14), %rcx
jmp 0x4719
movq 0x60(%r14), %rcx
leaq -0x4(%rcx), %r14
addq $-0x8, %rcx
movl 0xc(%rsp), %edx
xorl %eax, %eax
cmpl (%r14), %edx
je 0x4737
xorl %eax, %eax
cmpl (%rcx), %edx
sete %al
leal -0x1(,%rax,2), %eax
jmp 0x4737
pushq $-0x2
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0x38(%rdi), %rdi
leaq 0x4940(%rip), %rsi      # 0x99c4
callq 0x1bad
testq %rax, %rax
je 0x5090
popq %rcx
retq
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Load_Track_Data
int Load_Track_Data(DAZZ_TRACK *track, int i, void *data)
{ FILE      *dfile;
  int64      off;
  int        len;

  if (i < 0 || i >= track->nreads)
    { EPRINTF(EPLACE,"%s: Index out of bounds (Load_Track_Data)\n",Prog_Name);
      EXIT(-1);
    }

  if (track->size == 4)
    off = ((int *) track->anno)[i];
  else
    off = ((int64 *) track->anno)[i];
  len = track->alen[i];

  if (track->loaded)
    { strncpy(data,(void *) track->data + off,len);
      return (len);
    }

  dfile = (FILE *) track->data;
  if (ftello(dfile) != off)
    fseeko(dfile,off,SEEK_SET);
  if (len > 0)
    if (fread(data,len,1,dfile) != 1)
      { EPRINTF(EPLACE,"%s: Failed read of .data file (Load_Track_Data)\n",Prog_Name);
        EXIT(-1);
      }
  return (len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x5134
cmpl %esi, 0x14(%rdi)
jle 0x5134
movq %rdx, %rbx
cmpl $0x4, 0x10(%rdi)
movq 0x18(%rdi), %rcx
movl %esi, %eax
jne 0x50c6
movslq (%rcx,%rax,4), %r12
jmp 0x50ca
movq (%rcx,%rax,8), %r12
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %r15
movslq (%rcx,%rax,4), %r14
cmpl $0x0, 0x30(%rdi)
je 0x50ef
addq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1060
jmp 0x5125
movq %r15, %rdi
callq 0x1080
cmpq %r12, %rax
je 0x5109
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1230
testl %r14d, %r14d
jle 0x5125
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x515b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8ebd(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xb7a3(%rip), %rdx      # 0x108e8
leaq 0x4899(%rip), %rsi      # 0x99e5
xorl %eax, %eax
callq 0x11a0
pushq $0x1
popq %rdi
callq 0x1270
movq 0x8e96(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xb77c(%rip), %rdx      # 0x108e8
leaq 0x489d(%rip), %rsi      # 0x9a10
jmp 0x514c
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Write_Extra
int Write_Extra(FILE *afile, DAZZ_EXTRA *extra)
{ int slen; 

  FFWRITE(&(extra->vtype),sizeof(int),1,afile)
  FFWRITE(&(extra->nelem),sizeof(int),1,afile)
  FFWRITE(&(extra->accum),sizeof(int),1,afile)
  slen = strlen(extra->name);
  FFWRITE(&slen,sizeof(int),1,afile)
  FFWRITE(extra->name,1,slen,afile)
  FFWRITE(extra->value,8,extra->nelem,afile)

  return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x57d7
leaq 0x4(%rbx), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x57d7
leaq 0x8(%rbx), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x57d7
movq 0x10(%rbx), %rdi
callq 0x10e0
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x57d7
movq 0x10(%rbx), %rdi
movslq 0xc(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1280
cmpq %r15, %rax
jne 0x57d7
movq 0x18(%rbx), %rdi
movslq 0x4(%rbx), %rdx
pushq $0x8
popq %rsi
movq %r14, %rcx
callq 0x1280
movslq 0x4(%rbx), %rcx
cmpq %rcx, %rax
jne 0x57d7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x881a(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xb100(%rip), %rdx      # 0x108e8
leaq 0x4440(%rip), %rsi      # 0x9c2f
xorl %eax, %eax
callq 0x11a0
pushq $0x2
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: New_QV_Buffer
char **New_QV_Buffer(DAZZ_DB *db)
{ char **entry;
  char  *qvs;
  int    i;

  qvs   = (char *) Malloc(db->maxlen*5,"Allocating New QV Buffer");
  entry = (char **) Malloc(sizeof(char *)*5,"Allocating New QV Buffer");
  if (qvs == NULL || entry == NULL)
    EXIT(NULL);
  for (i = 0; i < 5; i++)
    entry[i] = qvs + i*db->maxlen;
  return (entry);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movslq 0x20(%rdi), %rax
leaq (%rax,%rax,4), %rdi
leaq 0x3dd1(%rip), %r15      # 0x9d3a
movq %r15, %rsi
callq 0x1bad
movq %rax, %rbx
pushq $0x28
popq %rdi
movq %r15, %rsi
callq 0x1bad
testq %rbx, %rbx
je 0x5fa7
testq %rax, %rax
je 0x5fa7
movslq 0x20(%r14), %rcx
xorl %edx, %edx
cmpq $0x5, %rdx
je 0x5fa1
movq %rbx, (%rax,%rdx,8)
incq %rdx
addq %rcx, %rbx
jmp 0x5f8f
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Load_QVentry
int Load_QVentry(DAZZ_DB *db, int i, char **entry, int ascii)
{ DAZZ_READ *reads;
  FILE      *quiva;
  int        rlen;

  if (db != Active_DB)
    { if (db->tracks == NULL || strcmp(db->tracks->name,".@qvs") != 0)
        { EPRINTF(EPLACE,"%s: QV's have not been opened (Load_QVentry)\n",Prog_Name);
          EXIT(1);
        }
      Active_QV = (DAZZ_QV *) db->tracks;
      Active_DB = db;
    }

  if (i < 0 || i >= db->nreads)
    { EPRINTF(EPLACE,"%s: Index out of bounds (Load_QVentry)\n",Prog_Name);
      EXIT(1);
    }

  reads = db->reads;
  quiva = Active_QV->quiva;
  rlen  = reads[i].rlen;

  fseeko(quiva,reads[i].coff,SEEK_SET);
  if (Uncompress_Next_QVentry(quiva,entry,Active_QV->coding+Active_QV->table[i],rlen))
    EXIT(1);

  if (ascii != 1)
    { char *deltag = entry[1];

      if (ascii != 2)
        { char x = deltag[rlen];
          deltag[rlen] = '\0';
          Number_Read(deltag);
          deltag[rlen] = x;
        }
      else
        { int j;
          int u = 'A'-'a';

          for (j = 0; j < rlen; j++)
            deltag[j] = (char) (deltag[j]+u);
        }
    }

  return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
cmpq %rdi, 0xa945(%rip)      # 0x10910
je 0x6001
movq 0x68(%r15), %r12
testq %r12, %r12
je 0x60d4
movq 0x8(%r12), %rdi
leaq 0x361d(%rip), %rsi      # 0x9603
callq 0x1190
testl %eax, %eax
jne 0x60d4
movq %r12, 0xa91e(%rip)      # 0x10918
movq %r15, 0xa90f(%rip)      # 0x10910
testl %ebp, %ebp
js 0x60ba
cmpl %ebp, 0x30(%r15)
jle 0x60ba
movq 0x60(%r15), %rax
movq 0xa8fa(%rip), %rcx      # 0x10918
movq 0x28(%rcx), %r12
movl %ebp, %r13d
imulq $0x28, %r13, %rcx
movl 0x4(%rax,%rcx), %r15d
movq 0x18(%rax,%rcx), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x1230
movq 0xa8d4(%rip), %rax      # 0x10918
movq 0x20(%rax), %rcx
movzwl (%rcx,%r13,2), %ecx
imulq $0x48, %rcx, %rdx
addq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %ecx
callq 0x8420
testl %eax, %eax
jne 0x60f3
cmpl $0x1, %ebx
je 0x60a9
movq 0x8(%r14), %r14
cmpl $0x2, %ebx
jne 0x6091
xorl %eax, %eax
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x60a9
addb $-0x20, (%r14,%rax)
incq %rax
jmp 0x6082
movslq %r15d, %rbx
movb (%r14,%rbx), %bpl
movb $0x0, (%r14,%rbx)
movq %r14, %rdi
callq 0x23f2
movb %bpl, (%r14,%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7f37(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xa81d(%rip), %rdx      # 0x108e8
leaq 0x3caf(%rip), %rsi      # 0x9d81
jmp 0x60ec
movq 0x7f1d(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xa803(%rip), %rdx      # 0x108e8
leaq 0x3c67(%rip), %rsi      # 0x9d53
xorl %eax, %eax
callq 0x11a0
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Next_Block_Exists
int Next_Block_Exists(Block_Looper *e_parse)
{ _Block_Looper *parse = (_Block_Looper *) e_parse;

  char       *disp;
  struct stat sts;

  if (parse->isDB)
    { if (parse->next+1 > parse->last)
        return (0);
      else
        return (1);
    }

  if (parse->next+1 > parse->last)
    return (0);

  if (parse->next < 0)
    disp = parse->root;
  else
    disp = MyNumbered_Suffix(parse->root,parse->next+1,parse->ppnt);

  if (stat(MyCatenate(parse->pwd,"/",disp,".las"),&sts))
    return (0);
  else
    return (1);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x28(%rdi)
movl 0x8(%rdi), %esi
je 0x6117
cmpl 0x4(%rbx), %esi
setl %al
jmp 0x6163
cmpl 0x4(%rbx), %esi
jge 0x6161
movq 0x10(%rbx), %rdx
testl %esi, %esi
js 0x6138
incl %esi
movq 0x20(%rbx), %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x4744
movq %rax, %rdx
movq 0x18(%rbx), %rdi
leaq 0x334b(%rip), %rsi      # 0x948e
leaq 0x3c5f(%rip), %rcx      # 0x9da9
callq 0x31cf
movq %rsp, %rsi
movq %rax, %rdi
callq 0x11c0
testl %eax, %eax
sete %al
jmp 0x6163
xorl %eax, %eax
movzbl %al, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Next_Block_Arg
FILE *Next_Block_Arg(Block_Looper *e_parse)
{ _Block_Looper *parse = (_Block_Looper *) e_parse;

  char *disp;
  FILE *input;

  if (parse->isDB)
    { fprintf(stderr,"%s: Cannot open a DB block as a file (Next_Block_Arg)\n",Prog_Name);
      exit (1);  //  exit even in interactive mode as this is a programming bug on
    }            //   the part of the caller

  parse->next += 1;
  if (parse->next > parse->last)
    return (NULL);

  if (parse->next < 0)
    disp  = parse->root;
  else
    disp = MyNumbered_Suffix(parse->root,parse->next,parse->ppnt);

  if ((input = fopen(MyCatenate(parse->pwd,"/",disp,".las"),"r")) == NULL)
    { if (parse->last != INT_MAX)
        { EPRINTF(EPLACE,"%s: %s.las is not present\n",Prog_Name,disp);
          EXIT(NULL);
        }
      return (NULL);
    }
  return (input);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x28(%rdi)
jne 0x61e3
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
cmpl 0x4(%rdi), %eax
jge 0x61d9
movq 0x10(%rbx), %r14
cmpl $-0x1, %eax
jl 0x61a2
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0x4744
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x32e1(%rip), %rsi      # 0x948e
leaq 0x3bf5(%rip), %rcx      # 0x9da9
movq %r14, %rdx
callq 0x31cf
leaq 0x3b8e(%rip), %rsi      # 0x9d51
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
jne 0x61db
cmpl $0x7fffffff, 0x4(%rbx)  # imm = 0x7FFFFFFF
jne 0x620a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x7e0e(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xa6f4(%rip), %rdx      # 0x108e8
leaq 0x3bb3(%rip), %rsi      # 0x9dae
xorl %eax, %eax
callq 0x11a0
pushq $0x1
popq %rdi
callq 0x1270
movq 0x7de7(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq 0xa6cd(%rip), %rdx      # 0x108e8
leaq 0x3bc3(%rip), %rsi      # 0x9de5
movq %r14, %rcx
xorl %eax, %eax
callq 0x11a0
jmp 0x6202
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Block_Arg_Root
char *Block_Arg_Root(Block_Looper *e_parse)
{ _Block_Looper *parse = (_Block_Looper *) e_parse;
  char *name;

  if (parse->next < 0)
    name = parse->root;
  else
    name = MyNumbered_Suffix(parse->root,parse->next,parse->ppnt);
  return (Strdup(name,"Allocating block root"));
}

// Assembly:
movq %rdi, %rax
movl 0x8(%rdi), %esi
movq 0x10(%rdi), %rdi
testl %esi, %esi
js 0x627e
pushq %rax
movq 0x20(%rax), %rdx
callq 0x4744
movq %rax, %rdi
addq $0x8, %rsp
leaq 0x3b91(%rip), %rsi      # 0x9e16
jmp 0x1c68
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/DB.c
// Function: Next_Block_Slice
char *Next_Block_Slice(Block_Looper *e_parse, int slice)
{ _Block_Looper *parse = (_Block_Looper *) e_parse;

  if (parse->slice == NULL)
    { int size = strlen(parse->pwd) + strlen(Block_Arg_Root(parse)) + 30;
      parse->slice =  (char *)  Malloc(size,"Block argument slice");
      if (parse->slice == NULL)
        EXIT(NULL);
    }

  if (parse->next+1 > parse->last)
    return (NULL);
  if (parse->next+slice > parse->last)
    slice = parse->last-parse->next;

  if (parse->first < 0)
    sprintf(parse->slice,"%s/%s",parse->pwd,parse->root);
  else
    sprintf(parse->slice,"%s/%s%c%d-%d%s",parse->pwd,parse->root,BLOCK_SYMBOL,parse->next+1,
                                          parse->next+slice,parse->ppnt);
  parse->next += slice;
  return (parse->slice);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x6303
movq 0x18(%rbx), %rdi
callq 0x10e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x625f
movq %rax, %rdi
callq 0x10e0
addl %r15d, %eax
addl $0x1e, %eax
movslq %eax, %rdi
leaq 0x3b3a(%rip), %rsi      # 0x9e2c
callq 0x1bad
movq %rax, %rdi
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x636b
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %r9d
movl %eax, %r15d
subl %r9d, %r15d
jle 0x634b
leal (%r9,%r14), %ecx
cmpl %eax, %ecx
cmovlel %r14d, %r15d
cmpl $0x0, (%rbx)
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
js 0x634f
leal (%r15,%r9), %r10d
incl %r9d
leaq 0x3b10(%rip), %rsi      # 0x9e47
pushq $0x40
popq %r8
xorl %eax, %eax
pushq 0x20(%rbx)
pushq %r10
callq 0x1260
popq %rcx
popq %rdx
jmp 0x635d
xorl %eax, %eax
jmp 0x6365
leaq 0x3aeb(%rip), %rsi      # 0x9e41
xorl %eax, %eax
callq 0x1260
addl %r15d, 0x8(%rbx)
movq 0x30(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Histogram_Runs
static void Histogram_Runs(uint64 *run, uint8 *stream, int rlen, int runChar)
{ int k, h;

  k = 0;
  while (k < rlen)
    { h = k;
      while (k < rlen && stream[k] == runChar)
        k += 1;
      if (k-h >= 256)
        run[255] += 1;
      else
        run[k-h] += 1;
      if (k < rlen)
        k += 1;
    }
}

// Assembly:
pushq %rbx
leaq 0x7f8(%rdi), %rax
movslq %edx, %r8
xorl %r9d, %r9d
cmpl %edx, %r9d
jge 0x6afb
movslq %r9d, %r10
cmpq %r10, %r8
je 0x6ac7
movzbl (%rsi,%r10), %r11d
cmpl %ecx, %r11d
jne 0x6acf
incq %r10
jmp 0x6ab3
xorl %r11d, %r11d
movl %edx, %r10d
jmp 0x6ad9
xorl %r11d, %r11d
cmpq %r8, %r10
setl %r11b
movl %r10d, %ebx
subl %r9d, %ebx
cmpl $0x100, %ebx            # imm = 0x100
movslq %ebx, %r9
leaq (%rdi,%r9,8), %r9
cmovgeq %rax, %r9
incq (%r9)
addl %r10d, %r11d
movl %r11d, %r9d
jmp 0x6aab
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Write_QVcoding
void Write_QVcoding(FILE *output, QVcoding *coding)
{
  //   Write out the endian key, run chars, and prefix (if not NULL)

  { uint16 half;
    int    len;

    half = 0x33cc;
    fwrite(&half,sizeof(uint16),1,output);

    if (coding->delChar < 0)
      half = 256;
    else
      half = (uint16) (coding->delChar);
    fwrite(&half,sizeof(uint16),1,output);

    if (coding->subChar < 0)
      half = 256;
    else
      half = (uint16) (coding->subChar);
    fwrite(&half,sizeof(uint16),1,output);

    len = strlen(coding->prefix);
    fwrite(&len,sizeof(int),1,output);
    fwrite(coding->prefix,1,len,output);
  }

  //   Write out the scheme tables

  Write_Scheme(coding->delScheme,output);
  if (coding->delChar >= 0)
    Write_Scheme(coding->dRunScheme,output);
  Write_Scheme(coding->insScheme,output);
  Write_Scheme(coding->mrgScheme,output);
  Write_Scheme(coding->subScheme,output);
  if (coding->subChar >= 0)
    Write_Scheme(coding->sRunScheme,output);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%rsp), %r12
movw $0x33cc, (%r12)         # imm = 0x33CC
pushq $0x2
popq %r13
pushq $0x1
popq %r15
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1280
movl 0x30(%r14), %eax
testl %eax, %eax
movl $0x100, %ebp            # imm = 0x100
cmovsl %ebp, %eax
movw %ax, (%r12)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1280
movl 0x34(%r14), %eax
testl %eax, %eax
cmovsl %ebp, %eax
movw %ax, (%r12)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1280
movq 0x40(%r14), %rdi
callq 0x10e0
leaq 0x4(%rsp), %r12
movl %eax, (%r12)
pushq $0x4
popq %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1280
movq 0x40(%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1280
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x763c
cmpl $0x0, 0x30(%r14)
js 0x75eb
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x763c
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x763c
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x763c
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x763c
cmpl $0x0, 0x34(%r14)
js 0x762d
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x763c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Write_Scheme
static void Write_Scheme(HScheme *scheme, FILE *out)
{ int     i;
  uint8   x;
  uint32 *bits;
  int    *lens;

  lens = scheme->codelens;
  bits = scheme->codebits;

  x = (uint8) (scheme->type);
  fwrite(&x,1,1,out);

  for (i = 0; i < 256; i++)
    { x = (uint8) (lens[i]);
      fwrite(&x,1,1,out);
      if (x > 0)
        fwrite(bits+i,sizeof(uint32),1,out);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsbl (%rdi), %edi
callq 0x1170
pushq $0x4
popq %r15
pushq $0x1
popq %r12
movq %r15, %r13
cmpq $0x404, %r13            # imm = 0x404
je 0x769a
movzbl 0x400(%r14,%r13), %ebp
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0x1170
testl %ebp, %ebp
je 0x7694
leaq (%r14,%r13), %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1280
addq $0x4, %r13
jmp 0x7660
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Free_QVcoding
void Free_QVcoding(QVcoding *coding)
{ if (coding->subChar >= 0)
    free(coding->sRunScheme);
  free(coding->subScheme);
  free(coding->mrgScheme);
  free(coding->insScheme);
  if (coding->delChar >= 0)
    free(coding->dRunScheme);
  free(coding->delScheme);
  free(coding->prefix);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x34(%rdi)
js 0x7b51
movq 0x28(%rbx), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
cmpl $0x0, 0x30(%rbx)
js 0x7b7b
movq 0x20(%rbx), %rdi
callq 0x1030
movq (%rbx), %rdi
callq 0x1030
movq 0x40(%rbx), %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Compress_Next_QVentry1
void Compress_Next_QVentry1(int rlen, char *del, char *tag, char *ins, char *mrg, char *sub,
                            FILE *output, QVcoding *coding, int lossy)
{ int clen;

  if (coding->delChar < 0)
    { Encode(coding->delScheme, output, (uint8 *) del, rlen);
      clen = rlen;
    }
  else
    { Encode_Run(coding->delScheme, coding->dRunScheme, output,
                 (uint8 *) del, rlen, coding->delChar);
      clen = Pack_Tag(tag,del,rlen,coding->delChar);
    }
  Number_Read(tag);
  Compress_Read(clen,tag);
  fwrite(tag,1,COMPRESSED_LEN(clen),output);

  if (lossy)
    { uint8 *insert = (uint8 *) ins;
      uint8 *merge  = (uint8 *) mrg;
      int    k;

      for (k = 0; k < rlen; k++)
        { insert[k] = (uint8) ((insert[k] >> 1) << 1);
          merge[k]  = (uint8) (( merge[k] >> 2) << 2);
        }
    }

  Encode(coding->insScheme, output, (uint8 *) ins, rlen);
  Encode(coding->mrgScheme, output, (uint8 *) mrg, rlen);
  if (coding->subChar < 0)
    Encode(coding->subScheme, output, (uint8 *) sub, rlen);
  else
    Encode_Run(coding->subScheme, coding->sRunScheme, output,
               (uint8 *) sub, rlen, coding->subChar);
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movl %edi, %ebp
movl 0x60(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %rdx
movl 0x30(%r14), %r9d
movq (%r14), %rdi
testl %r9d, %r9d
movq %rdx, 0x10(%rsp)
js 0x7bf5
movq 0x20(%r14), %rsi
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x7e98
movl 0x30(%r14), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x821b
movl %eax, %ebx
jmp 0x7c04
movq %rdx, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x7cc4
movl %ebp, %ebx
movq %r13, %rdi
callq 0x23f2
movl %ebx, %edi
movq %r13, %rsi
callq 0x22dd
addl $0x3, %ebx
sarl $0x2, %ebx
movslq %ebx, %rdx
pushq $0x1
popq %rsi
movq %r13, %rdi
movq 0x10(%rsp), %rbx
movq %rbx, %rcx
callq 0x1280
cmpl $0x0, 0x4(%rsp)
je 0x7c59
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x7c59
andb $-0x2, (%r12,%rax)
andb $-0x4, (%r15,%rax)
incq %rax
jmp 0x7c45
movq 0x8(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x7cc4
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x7cc4
movl 0x34(%r14), %r9d
movq 0x18(%r14), %rdi
testl %r9d, %r9d
js 0x7caa
movq 0x28(%r14), %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
movl %ebp, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7e98
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
movl %ebp, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7cc4
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Pack_Tag
static int Pack_Tag(char *tags, char *qvs, int rlen, int rchar)
{ int j, k;

  j = 0;
  for (k = 0; k < rlen; k++)
    if (qvs[k] != rchar)
      tags[j++] = tags[k];
  tags[j] = '\0';
  return (j);
}

// Assembly:
xorl %r8d, %r8d
testl %edx, %edx
cmovlel %r8d, %edx
xorl %r9d, %r9d
movslq %r9d, %rax
cmpq %r8, %rdx
je 0x824a
movsbl (%rsi,%r8), %r10d
cmpl %ecx, %r10d
je 0x8245
movb (%rdi,%r8), %r10b
leal 0x1(%rax), %r9d
movb %r10b, (%rdi,%rax)
incq %r8
jmp 0x8227
movb $0x0, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Reheap
static void Reheap(int s, HTree **heap, int hsize)
{ int      c, l, r;
  HTree   *hs, *hr, *hl;

  c  = s;
  hs = heap[s];
  while ((l = 2*c) <= hsize)
    { r  = l+1;
      hl = heap[l];
      hr = heap[r];
      if (r > hsize || hr->count > hl->count)
        { if (hs->count > hl->count)
            { heap[c] = hl;
              c = l;
            }
          else
            break;
        }
      else
        { if (hs->count > hr->count)
            { heap[c] = hr;
              c = r;
            }
          else
            break;
        }
    }
  if (c != s)
    heap[c] = hs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %eax
movq (%rsi,%rax,8), %rax
movl %edi, %ecx
leal (%rcx,%rcx), %r9d
movslq %ecx, %r8
cmpl %edx, %r9d
jg 0x8d5f
movslq %r9d, %r10
movq (%rsi,%r10,8), %r10
jge 0x8d49
movl %r9d, %ebp
orl $0x1, %ebp
movslq %ebp, %r11
movq (%rsi,%r11,8), %r15
movq 0x10(%r15), %r14
movq 0x10(%r10), %rbx
movq 0x10(%rax), %r11
cmpq %rbx, %r14
ja 0x8d51
movq %r15, %r10
movl %ebp, %r9d
cmpq %r14, %r11
ja 0x8d56
jmp 0x8d5f
movq 0x10(%rax), %r11
movq 0x10(%r10), %rbx
cmpq %rbx, %r11
jbe 0x8d5f
movq %r10, (%rsi,%r8,8)
movl %r9d, %ecx
jmp 0x8d09
cmpl %edi, %ecx
je 0x8d67
movq %rax, (%rsi,%r8,8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/thegenemyers[P]DASCRUBBER/QV.c
// Function: Build_Table
static void Build_Table(HTree *node, int code, int len, uint32 *codebits, int *codelens)
{ if (node->rgt == NULL)
    { uint64 symbol = (uint64) (node->lft);
      codebits[symbol] = code;
      codelens[symbol] = len;
    }
  else
    { code <<= 1;
      len   += 1;
      Build_Table(node->lft,code,len,codebits,codelens);
      Build_Table(node->rgt,code+1,len,codebits,codelens);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
cmpq $0x0, 0x8(%r12)
je 0x8db2
leal (%r15,%r15), %esi
incl %ebp
movq (%r12), %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x8d6e
movq 0x8(%r12), %r12
leal 0x1(,%r15,2), %r15d
jmp 0x8d84
movq (%r12), %rax
movl %r15d, (%r14,%rax,4)
movl %ebp, (%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq