LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, 0xd424(%rip)      # 0x12900
je 0x550a
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x55ca
leaq 0x6964(%rip), %rcx      # 0xbe56
cmpq %rcx, 0x8(%rax)
jne 0x55ca
movq %rax, 0xd405(%rip)      # 0x12908
movq %rdi, 0xd3f6(%rip)      # 0x12900
testl %esi, %esi
js 0x55c5
cmpl %esi, 0x30(%rdi)
jle 0x55c5
movq 0xd3e6(%rip), %rax      # 0x12908
movq 0x10(%rax), %rcx
movq 0x18(%rax), %r15
movl %esi, %eax
movq (%rcx,%rax,8), %r12
movq 0x60(%rdi), %rcx
leaq (%rax,%rax,4), %rax
movl 0x4(%rcx,%rax,8), %r14d
movq %r15, %rdi
callq 0x1080
cmpq %r12, %rax
je 0x5557
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1230
leal 0x3(%r14), %eax
sarl $0x2, %eax
testl %eax, %eax
jle 0x557a
movl %eax, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x55cf
movl %r14d, %edi
movq %rbx, %rsi
callq 0x3400
movb $0x4, %al
cmpl $0x1, %ebp
jne 0x55b7
movb (%rbx), %al
movq %rbx, %rcx
cmpb $0x4, %al
je 0x55b2
leaq 0x69f6(%rip), %rdx      # 0xbf92
movq %rbx, %rcx
movsbq %al, %rax
movb (%rax,%rdx), %al
movb %al, (%rcx)
movb 0x1(%rcx), %al
incq %rcx
cmpb $0x4, %al
jne 0x559f
movb $0x0, (%rcx)
xorl %eax, %eax
movb %al, -0x1(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1791
callq 0x1741
callq 0x1769
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x38(%rdi), %esi
testl %esi, %esi
jle 0x57fb
movq 0x48(%rbx), %r12
leaq 0x5d24(%rip), %rdi      # 0xb4ee
movq %rdi, %rdx
callq 0x58f8
leaq 0x608a(%rip), %rcx      # 0xb863
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x4215
leaq 0x6563(%rip), %rsi      # 0xbd51
movq %rax, %rdi
callq 0x1240
movq %rax, %r12
jmp 0x57fe
xorl %r12d, %r12d
movq %r12, %r13
testq %r12, %r12
jne 0x5832
movq 0x48(%rbx), %rdi
leaq 0x5cdd(%rip), %rsi      # 0xb4ee
leaq 0x604b(%rip), %rcx      # 0xb863
movq %r15, %rdx
callq 0x4215
leaq 0x652a(%rip), %rsi      # 0xbd51
movq %rax, %rdi
callq 0x1240
movq %rax, %r13
testq %r13, %r13
je 0x588e
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x58e2
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r13, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x58ed
movl 0x8(%rsp), %ecx
testl %ecx, %ecx
je 0x5895
xorl %eax, %eax
testl %ecx, %ecx
jg 0x589a
movq %r15, %rdi
movq %r13, %rsi
callq 0x1880
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
jmp 0x58d4
movl $0x1, %eax
movl %eax, (%r14)
movq %r13, %rdi
callq 0x10c0
testq %r12, %r12
je 0x58b8
movq 0x60(%rbx), %rcx
leaq -0x4(%rcx), %rbx
addq $-0x8, %rcx
jmp 0x58bc
leaq 0x4(%rbx), %rcx
movl 0xc(%rsp), %edx
xorl %eax, %eax
cmpl (%rbx), %edx
je 0x58d4
xorl %eax, %eax
cmpl (%rcx), %edx
sete %al
leal -0x1(,%rax,2), %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r13, %rsi
callq 0x1814
movq %r15, %rdi
movq %r13, %rsi
callq 0x184a
// File: /workspace/github_c_makefile_star2_O1/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 0x57cd(%rip), %rsi      # 0xb9c4
callq 0x2b85
testq %rax, %rax
je 0x6203
popq %rcx
retq
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O1/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 0x62ab
cmpl %esi, 0x14(%rdi)
jle 0x62ab
movq %rdx, %rbx
cmpl $0x4, 0x10(%rdi)
movq 0x18(%rdi), %rcx
movl %esi, %eax
jne 0x623b
movslq (%rcx,%rax,4), %r12
jmp 0x623f
movq (%rcx,%rax,8), %r12
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %r15
movslq (%rcx,%rax,4), %r14
cmpl $0x0, 0x30(%rdi)
je 0x6264
addq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1060
jmp 0x629c
movq %r15, %rdi
callq 0x1080
cmpq %r12, %rax
je 0x627e
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1230
testl %r14d, %r14d
jle 0x629c
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x62b0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1aba
callq 0x1a92
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x6900
leaq 0x4(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x6905
leaq 0x8(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x690a
movq 0x10(%rbx), %rdi
callq 0x10e0
leaq 0xc(%rsp), %rdi
movl %eax, (%rdi)
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x690f
movq 0x10(%rbx), %rdi
movslq 0xc(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1280
cmpq %r15, %rax
jne 0x6914
movq 0x18(%rbx), %rdi
movslq 0x4(%rbx), %rdx
movl $0x8, %esi
movq %r14, %rcx
callq 0x1280
movslq 0x4(%rbx), %rcx
cmpq %rcx, %rax
jne 0x6919
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1c42
callq 0x1c6a
callq 0x1c92
callq 0x1cba
callq 0x1ce2
callq 0x1d0a
// File: /workspace/github_c_makefile_star2_O1/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 0x4b82(%rip), %r15      # 0xbd3a
movq %r15, %rsi
callq 0x2b85
movq %rax, %rbx
movl $0x28, %edi
movq %r15, %rsi
callq 0x2b85
testq %rbx, %rbx
je 0x71f6
testq %rax, %rax
je 0x71f6
movslq 0x20(%r14), %rcx
xorl %edx, %edx
movq %rbx, (%rax,%rdx,8)
incq %rdx
addq %rcx, %rbx
cmpq $0x5, %rdx
jne 0x71e0
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O1/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, 0xb6f4(%rip)      # 0x12910
je 0x7252
movq 0x68(%r15), %r12
testq %r12, %r12
je 0x7337
movq 0x8(%r12), %rdi
leaq 0x43cc(%rip), %rsi      # 0xb603
callq 0x1190
testl %eax, %eax
jne 0x7337
movq %r12, 0xb6cd(%rip)      # 0x12918
movq %r15, 0xb6be(%rip)      # 0x12910
testl %ebp, %ebp
js 0x7332
cmpl %ebp, 0x30(%r15)
jle 0x7332
movq 0x60(%r15), %rax
movq 0xb6a9(%rip), %rcx      # 0x12918
movq 0x28(%rcx), %r12
movl %ebp, %r13d
leaq (,%r13,4), %rcx
addq %r13, %rcx
movl 0x4(%rax,%rcx,8), %r15d
movq 0x18(%rax,%rcx,8), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0x1230
movq 0xb67c(%rip), %rax      # 0x12918
movq 0x20(%rax), %rcx
movzwl (%rcx,%r13,2), %ecx
leaq (%rcx,%rcx,8), %rdx
shll $0x3, %edx
addq 0x18(%rax), %rdx
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %ecx
callq 0x95c3
testl %eax, %eax
jne 0x733c
cmpl $0x1, %ebx
je 0x7321
movq 0x8(%r14), %rax
cmpl $0x2, %ebx
jne 0x72e5
testl %r15d, %r15d
jle 0x7321
xorl %ecx, %ecx
addb $-0x20, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x72d7
jmp 0x7321
movslq %r15d, %rcx
movb (%rax,%rcx), %dl
movb $0x0, (%rax,%rcx)
movb (%rax), %sil
movq %rax, %rdi
testb %sil, %sil
je 0x731b
leaq 0x4c9f(%rip), %r8       # 0xbfa0
movq %rax, %rdi
movsbq %sil, %rsi
movb (%rsi,%r8), %sil
movb %sil, (%rdi)
movb 0x1(%rdi), %sil
incq %rdi
testb %sil, %sil
jne 0x7304
movb $0x4, (%rdi)
movb %dl, (%rax,%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1e4a
callq 0x1e22
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O1/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 0x7362
cmpl 0x4(%rbx), %esi
setl %al
jmp 0x73ae
cmpl 0x4(%rbx), %esi
jge 0x73ac
movq 0x10(%rbx), %rdx
testl %esi, %esi
js 0x7383
incl %esi
movq 0x20(%rbx), %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x58f8
movq %rax, %rdx
movq 0x18(%rbx), %rdi
leaq 0x4100(%rip), %rsi      # 0xb48e
leaq 0x4a14(%rip), %rcx      # 0xbda9
callq 0x4215
movq %rsp, %rsi
movq %rax, %rdi
callq 0x11c0
testl %eax, %eax
sete %al
jmp 0x73ae
xorl %eax, %eax
movzbl %al, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x742e
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
cmpl 0x4(%rdi), %eax
jge 0x7424
movq 0x10(%rbx), %r14
cmpl $-0x1, %eax
jl 0x73ed
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0x58f8
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x4096(%rip), %rsi      # 0xb48e
leaq 0x49aa(%rip), %rcx      # 0xbda9
movq %r14, %rdx
callq 0x4215
leaq 0x4943(%rip), %rsi      # 0xbd51
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
jne 0x7426
cmpl $0x7fffffff, 0x4(%rbx)  # imm = 0x7FFFFFFF
jne 0x7433
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1e72
movq %r14, %rdi
callq 0x1e9a
// File: /workspace/github_c_makefile_star2_O1/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 0x748d
pushq %rax
movq 0x20(%rax), %rdx
callq 0x58f8
movq %rax, %rdi
addq $0x8, %rsp
leaq 0x4982(%rip), %rsi      # 0xbe16
jmp 0x2c42
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/DB.c
// Function: Free_Block_Arg
void Free_Block_Arg(Block_Looper *e_parse)
{ _Block_Looper *parse = (_Block_Looper *) e_parse;

  free(parse->root);
  free(parse->pwd);
  free(parse->slice);
  free(parse);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x30(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x30(%rdi)
jne 0x750d
movq 0x18(%rbx), %rdi
callq 0x10e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x746e
movq %rax, %rdi
callq 0x10e0
addl %r15d, %eax
addl $0x1e, %eax
movslq %eax, %rdi
leaq 0x492d(%rip), %rsi      # 0xbe2c
callq 0x2b85
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x757d
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %r9d
movl %eax, %r15d
subl %r9d, %r15d
jle 0x755d
leal (%r9,%r14), %ecx
cmpl %eax, %ecx
cmovlel %r14d, %r15d
cmpl $0x0, (%rbx)
movq 0x30(%rbx), %rdi
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
js 0x7561
leal (%r15,%r9), %r10d
incl %r9d
leaq 0x4902(%rip), %rsi      # 0xbe47
movl $0x40, %r8d
xorl %eax, %eax
pushq 0x20(%rbx)
pushq %r10
callq 0x1260
addq $0x10, %rsp
jmp 0x756f
xorl %eax, %eax
jmp 0x7577
leaq 0x48d9(%rip), %rsi      # 0xbe41
xorl %eax, %eax
callq 0x1260
addl %r15d, 0x8(%rbx)
movq 0x30(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O1/thegenemyers[P]DASCRUBBER/QV.c
// Function: Read_Lines
int Read_Lines(FILE *input, int nlines)
{ int   i, rlen;
  int   tmax;
  char *tread;
  char *other;

  if (Read == NULL)
    { tmax  = MIN_BUFFER;
      tread = (char *) Malloc(5*tmax,"Allocating QV entry read buffer");
      if (tread == NULL)
        EXIT(-2);
      Rmax = tmax;
      Read = tread;
    }

  Nline += 1;
  if (fgets(Read,Rmax,input) == NULL)
    return (-1);

  rlen = strlen(Read);
  while (Read[rlen-1] != '\n')
    { tmax  = ((int) 1.4*Rmax) + MIN_BUFFER;
      tread = (char *) Realloc(Read,5*tmax,"Reallocating QV entry read buffer");
      if (tread == NULL)
        EXIT(-2);
      Rmax = tmax;
      Read = tread;
      if (fgets(Read+rlen,Rmax-rlen,input) == NULL)
        { EPRINTF(EPLACE,"Line %d: Last line does not end with a newline !\n",Nline);
          EXIT(-2);
        }
      rlen += strlen(Read+rlen);
    }
  other = Read;
  for (i = 1; i < nlines; i++)
    { other += Rmax;
      Nline += 1;
      if (fgets(other,Rmax,input) == NULL)
        { EPRINTF(EPLACE,"Line %d: incomplete last entry of .quiv file\n",Nline);
          EXIT(-2);
        }
      if (rlen != (int) strlen(other))
        { EPRINTF(EPLACE,"Line %d: Lines for an entry are not the same length\n",Nline);
          EXIT(-2);
        }
    }
  return (rlen-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpq $0x0, 0xb04a(%rip)      # 0x12930
jne 0x7913
leaq 0x4859(%rip), %rsi      # 0xc148
movl $0x1388, %edi           # imm = 0x1388
callq 0x2b85
testq %rax, %rax
je 0x7a1c
movl $0x3e8, 0x88ac(%rip)    # imm = 0x3E8
movq %rax, 0xb01d(%rip)      # 0x12930
incl 0xb01f(%rip)            # 0x12938
movq 0xb010(%rip), %rdi      # 0x12930
movl 0x8892(%rip), %esi      # 0x101b8
movq %r14, %rdx
callq 0x1180
testq %rax, %rax
je 0x7a04
movq 0xaff2(%rip), %r12      # 0x12930
movq %r12, %rdi
callq 0x10e0
movq %rax, %r15
movslq %r15d, %r13
cmpb $0xa, -0x1(%r12,%r13)
je 0x79c7
movslq 0x885d(%rip), %r13      # 0x101b8
addq $0x3e8, %r13            # imm = 0x3E8
leaq (,%r13,4), %rsi
addq %r13, %rsi
movq %r12, %rdi
leaq 0x47f1(%rip), %rdx      # 0xc168
callq 0x2bdd
testq %rax, %rax
je 0x7a1c
movl %r13d, 0x882c(%rip)     # 0x101b8
movq %rax, 0xaf9d(%rip)      # 0x12930
movslq %r15d, %rbp
addq %rbp, %rax
subl %r15d, %r13d
movq %rax, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x1180
testq %rax, %rax
je 0x7a26
movq 0xaf7a(%rip), %r12      # 0x12930
leaq (%r12,%rbp), %rdi
callq 0x10e0
movq %rax, %r15
addq %rbp, %r15
jmp 0x7949
decq %r13
cmpl $0x2, %ebx
jl 0x7a0a
decl %ebx
movslq 0x87e0(%rip), %rsi      # 0x101b8
addq %rsi, %r12
incl 0xaf57(%rip)            # 0x12938
movq %r12, %rdi
movq %r14, %rdx
callq 0x1180
testq %rax, %rax
je 0x7a2b
movq %r12, %rdi
callq 0x10e0
cmpl %eax, %r15d
jne 0x7a30
decl %ebx
jne 0x79d1
jmp 0x7a0a
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x1270
callq 0x1fcb
callq 0x2019
callq 0x1ff2
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edx, %edx
jle 0x7cb5
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x7f8(%rdi), %rax
movl %edx, %r8d
xorl %r9d, %r9d
movslq %r9d, %r11
leal 0x1(%r11), %ebx
cmpl %ebx, %edx
cmovgl %edx, %ebx
movzbl (%rsi,%r11), %r14d
movb $0x1, %bpl
movl %r9d, %r10d
cmpl %ecx, %r14d
jne 0x7c8a
incq %r11
movl %r9d, %r10d
cmpq %r8, %r11
setl %bpl
jge 0x7c87
movzbl (%rsi,%r11), %r14d
incl %r10d
incq %r11
cmpl %ecx, %r14d
je 0x7c6c
jmp 0x7c8a
movl %ebx, %r10d
movl %r10d, %r11d
subl %r9d, %r11d
cmpl $0x100, %r11d           # imm = 0x100
movslq %r11d, %r9
leaq (%rdi,%r9,8), %r9
cmovgeq %rax, %r9
incq (%r9)
movzbl %bpl, %r9d
addl %r10d, %r9d
cmpl %edx, %r9d
jl 0x7c4a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2(%rsp), %r15
movw $0x33cc, (%r15)         # imm = 0x33CC
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1280
movl 0x30(%r14), %eax
testl %eax, %eax
movl $0x100, %ebp            # imm = 0x100
cmovsl %ebp, %eax
movw %ax, (%r15)
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1280
movl 0x34(%r14), %eax
testl %eax, %eax
cmovsl %ebp, %eax
movw %ax, (%r15)
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1280
movq 0x40(%r14), %rdi
callq 0x10e0
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1280
movq 0x40(%r14), %rdi
movslq (%r15), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x1280
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x87f3
cmpl $0x0, 0x30(%r14)
js 0x87aa
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x87f3
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x87f3
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x87f3
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x87f3
cmpl $0x0, 0x34(%r14)
js 0x87e8
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x87f3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsbl (%rdi), %edi
callq 0x1170
movl $0x4, %r15d
movzbl 0x400(%r14,%r15), %ebp
movsbl %bpl, %edi
movq %rbx, %rsi
callq 0x1170
testl %ebp, %ebp
je 0x883d
leaq (%r14,%r15), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1280
addq $0x4, %r15
cmpq $0x404, %r15            # imm = 0x404
jne 0x880e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8cae
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 0x8cd8
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_O1/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 $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movl %edi, %ebp
movl 0x70(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x68(%rsp), %r14
movq 0x60(%rsp), %rdx
movl 0x30(%r14), %r9d
movq (%r14), %rdi
testl %r9d, %r9d
movq %r14, 0x20(%rsp)
js 0x8d74
movq 0x20(%r14), %rsi
movq %rdx, 0x18(%rsp)
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x9045
testl %ebp, %ebp
jle 0x8d88
movl 0x30(%r14), %eax
movl %ebp, %r8d
movl %ebp, %ecx
xorl %edx, %edx
xorl %ebp, %ebp
movsbl (%rbx,%rdx), %esi
cmpl %esi, %eax
je 0x8d6a
movb (%r13,%rdx), %sil
movslq %ebp, %rdi
incl %ebp
movb %sil, (%r13,%rdi)
incq %rdx
cmpq %rdx, %rcx
jne 0x8d53
jmp 0x8d8d
movq %rdx, %r14
movq %rdx, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x8e60
movl %ebp, %ebx
jmp 0x8d9e
movl %ebp, %r8d
xorl %ebp, %ebp
movslq %ebp, %rax
movb $0x0, (%r13,%rax)
movl %r8d, %ebx
movq 0x18(%rsp), %r14
movq %r13, %rdi
callq 0x34e2
movl %ebp, %edi
movq %r13, %rsi
callq 0x33a0
addl $0x3, %ebp
sarl $0x2, %ebp
movslq %ebp, %rdx
movl $0x1, %esi
movq %r13, %rdi
movq %r14, %rcx
callq 0x1280
cmpl $0x0, 0xc(%rsp)
sete %al
testl %ebx, %ebx
setle %cl
orb %al, %cl
jne 0x8df0
movl %ebx, %eax
xorl %ecx, %ecx
andb $-0x2, (%r12,%rcx)
andb $-0x4, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x8dde
movq 0x20(%rsp), %r13
movq 0x8(%r13), %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x8e60
movq 0x10(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x8e60
movl 0x34(%r13), %r9d
movq 0x18(%r13), %rdi
testl %r9d, %r9d
js 0x8e46
movq 0x28(%r13), %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
movl %ebx, %r8d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9045
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movl %ebx, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8e60
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %eax
movq (%rsi,%rax,8), %rax
leal (%rdi,%rdi), %ecx
movl %edi, %r10d
cmpl %edx, %ecx
jg 0xa0c7
movl %edi, %r8d
movslq %ecx, %r9
movq (%rsi,%r9,8), %r9
cmpl %edx, %ecx
jge 0xa095
movl %ecx, %r10d
orl $0x1, %r10d
movslq %r10d, %r11
movq (%rsi,%r11,8), %rbx
movq 0x10(%rbx), %r11
cmpq 0x10(%r9), %r11
jbe 0xa0a1
movq 0x10(%rax), %r10
cmpq 0x10(%r9), %r10
ja 0xa0ad
jmp 0xa0c4
movq %rbx, %r9
movl %r10d, %ecx
cmpq %r11, 0x10(%rax)
jbe 0xa0c4
movl %ecx, %r10d
movslq %r8d, %rcx
movq %r9, (%rsi,%rcx,8)
leal (%r10,%r10), %ecx
movl %r10d, %r8d
cmpl %edx, %ecx
jle 0xa072
jmp 0xa0c7
movl %r8d, %r10d
cmpl %edi, %r10d
je 0xa0d3
movslq %r10d, %rcx
movq %rax, (%rsi,%rcx,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa119
leal (%r15,%r15), %esi
incl %ebp
movq (%r12), %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0xa0d5
movq 0x8(%r12), %r12
leal 0x1(,%r15,2), %r15d
jmp 0xa0eb
movq (%r12), %rax
movl %r15d, (%r14,%rax,4)
movl %ebp, (%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/algorithm.c
// Function: get_algorithm_type
SUPERVISED_ALGORITHM_TYPE get_algorithm_type(int algorithm)
{
 int i;
 for (i = 0; i < CLASSIFICATION_ALGORITHM_COUNT; i++)
   if (algorithm == SELECTMAX + i)
     return CLASSIFICATION;
 for (i = 0; i < REGRESSION_ALGORITHM_COUNT; i++)
   if (algorithm == ONEFEATURE + i)
     return REGRESSION;
 return UNDEFINED_ALGORITHM;
}

// Assembly:
leal -0x3e8(%rdi), %ecx
xorl %eax, %eax
cmpl $0x29, %ecx
jb 0x4487
addl $0xfffff830, %edi       # imm = 0xFFFFF830
xorl %eax, %eax
cmpl %eax, %edi
je 0x4482
incl %eax
cmpl $0x11, %eax
jne 0x4471
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/algorithm.c
// Function: check_supervised_algorithm_type
int check_supervised_algorithm_type(int algorithm, Datasetptr current_dataset)
{
 /*!Last Changed 05.03.2006*/
 if (in_list(algorithm, 1, HMM) && current_dataset->storetype != STORE_SEQUENTIAL)
  {
   printf(m1471);
   return 0;
  }
 if (current_dataset->storetype == STORE_KERNEL && !in_list(algorithm, 6, SVM, SIMPLEXSVM, SVMREG, SIMPLEXSVMREG, KNN, KNNREG))
  {
   printf(m1472);
   return 0;
  }
 if (get_algorithm_type(algorithm) == CLASSIFICATION && current_dataset->classno == 0)
  {
   printf(m1132);
   return 0;
  }
 if (get_algorithm_type(algorithm) == REGRESSION && current_dataset->classno != 0)
  {
   printf(m1133);
   return 0;
  }
 return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %esi
movl $0x3fe, %edx            # imm = 0x3FE
xorl %eax, %eax
callq 0x39a80
testl %eax, %eax
je 0x4591
cmpl $0x2, 0x140713c(%rbx)
jne 0x45f1
cmpl $0x3, 0x140713c(%rbx)
jne 0x45d1
movl %r14d, %edi
movl $0x6, %esi
movl $0x3f9, %edx            # imm = 0x3F9
movl $0x3fa, %ecx            # imm = 0x3FA
movl $0x7d8, %r8d            # imm = 0x7D8
movl $0x7d9, %r9d            # imm = 0x7D9
xorl %eax, %eax
pushq $0x7d1                  # imm = 0x7D1
pushq $0x3e9                  # imm = 0x3E9
callq 0x39a80
addq $0x10, %rsp
testl %eax, %eax
je 0x4621
leal -0x411(%r14), %eax
cmpl $-0x29, %eax
jae 0x45fa
addl $0xfffff830, %r14d      # imm = 0xFFFFF830
movl $0x1, %eax
cmpl $0x10, %r14d
jbe 0x4612
jmp 0x4638
leaq 0x9e57c(%rip), %rdi     # 0xa2b74
jmp 0x4631
cmpl $0x0, 0x10(%rbx)
je 0x462a
addl $0xfffff830, %r14d      # imm = 0xFFFFF830
movl $0x1, %eax
cmpl $0x11, %r14d
jae 0x4638
cmpl $0x0, 0x10(%rbx)
je 0x4638
leaq 0x9e4eb(%rip), %rdi     # 0xa2b0a
jmp 0x4631
leaq 0x9e476(%rip), %rdi     # 0xa2a9e
jmp 0x4631
leaq 0x9e50e(%rip), %rdi     # 0xa2b3f
callq 0x4090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/algorithm.c
// Function: get_supervised_algorithm_index
int get_supervised_algorithm_index(char* algname)
{
 /*!Last Changed 11.03.2006*/
 int i;
 for (i = 0; i < CLASSIFICATION_ALGORITHM_COUNT; i++)
   if (strIcmp(algname, classification_algorithms[SELECTMAX + i].name) == 0)
     return SELECTMAX + i;
 for (i = 0; i < REGRESSION_ALGORITHM_COUNT; i++)
   if (strIcmp(algname, regression_algorithms[ONEFEATURE + i].name) == 0)
     return ONEFEATURE + i;
 return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x3e8, %ebx            # imm = 0x3E8
xorl %r15d, %r15d
leaq 0xcc74b(%rip), %r12     # 0xd11c0
movq 0x9c50(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x3a318
testl %eax, %eax
je 0x4acf
incl %ebx
addq $0x28, %r15
cmpq $0x668, %r15            # imm = 0x668
jne 0x4a75
movl $0x7d0, %ebx            # imm = 0x7D0
xorl %r15d, %r15d
leaq 0xccd89(%rip), %r12     # 0xd1830
movq 0x13890(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x3a318
testl %eax, %eax
je 0x4acf
incl %ebx
addq $0x28, %r15
cmpq $0x2a8, %r15            # imm = 0x2A8
jne 0x4aa7
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/binary.c
// Function: empty_binary_function
Binaryfunctionptr empty_binary_function()
{
 /*!Last Changed 19.04.2008*/
 Binaryfunctionptr result;
 result = (Binaryfunctionptr) safemalloc(sizeof(Binaryfunction), "empty_binary_function", 2);
 result->termcount = 0;
 result->terms = NULL;
 return result;
}

// Assembly:
pushq %rax
leaq 0x9c4a7(%rip), %rsi     # 0xa2cab
movl $0x10, %edi
movl $0x2, %edx
callq 0x390f5
movl $0x0, 0x8(%rax)
movq $0x0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/binary.c
// Function: free_binary_function
void free_binary_function(Binaryfunctionptr bf)
{
 /*!Last Changed 19.04.2008*/
 int i;
 for (i = 0; i < bf->termcount; i++)
  {
   safe_free(bf->terms[i].complement);
   safe_free(bf->terms[i].variables);
  }
 safe_free(bf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x6860
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x39194
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x39194
incq %r15
movslq 0x8(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x6837
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x39194
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/binary.c
// Function: evaluate_binary_function
BOOLEAN evaluate_binary_function(Binaryfunctionptr bf, int* values)
{
 /*!Last Changed 20.04.2008*/
 int i, j, index, complement;
 for (i = 0; i < bf->termcount; i++)
  {
   for (j = 0; j < bf->terms[i].count; j++)
    {
     index = bf->terms[i].variables[j];
     complement = bf->terms[i].complement[j];
     if ((values[index] && complement) || (!values[index] && !complement))
       break;
    }
   if (j == bf->terms[i].count)
     return BOOLEAN_TRUE;
  }
 return BOOLEAN_FALSE;
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x6ad3
pushq %rbp
pushq %rbx
movq (%rdi), %rcx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
movl 0x10(%rcx,%rdi,8), %r8d
movl $0x0, %r9d
testl %r8d, %r8d
jle 0x6ac0
leaq (%rcx,%rdi,8), %r9
movq (%r9), %r10
movq 0x8(%r9), %r11
xorl %r9d, %r9d
movslq (%r10,%r9,4), %rbx
cmpl $0x0, (%rsi,%rbx,4)
setne %bl
cmpl $0x0, (%r11,%r9,4)
setne %bpl
cmpb %bl, %bpl
je 0x6ac0
incq %r9
cmpq %r9, %r8
jne 0x6a9c
movl %r8d, %r9d
cmpl 0x10(%rcx,%rdi,8), %r9d
je 0x6ad6
incq %rdx
cmpq %rax, %rdx
jne 0x6a7a
xorl %eax, %eax
jmp 0x6adb
xorl %eax, %eax
retq
movl $0x1, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/binary.c
// Function: generate_random_data_from_binary_function
void generate_random_data_from_binary_function(Binaryfunctionptr bf, int d, char* fname)
{
 /*!Last Changed 20.04.2008*/
 FILE* outfile;
 int* iterator;
 int result, i;
 outfile = fopen(fname, "w");
 if (!outfile)
  {
   printf(m1306);
   return;
  }
 iterator = first_iterator(d);
 do{
   result = evaluate_binary_function(bf, iterator);
   for (i = 0; i < d; i++)
     switch (iterator[i])
      {
       case BOOLEAN_FALSE:fprintf(outfile, "F ");
                          break;
       case  BOOLEAN_TRUE:fprintf(outfile, "T ");
                          break;
      }
   switch (result)
    {
     case BOOLEAN_FALSE:fprintf(outfile, "F\n");
                        break;
     case  BOOLEAN_TRUE:fprintf(outfile, "T\n");
                        break;
    }
 }while(next_iterator(iterator, d, 1));
 safe_free(iterator);
 fclose(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, 0x10(%rsp)
leaq 0xa1da7(%rip), %rsi     # 0xa88a1
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x6bd3
movq %rax, %r15
movl %ebp, %edi
callq 0x38632
movq %rax, %r12
movl %ebp, %r13d
leaq 0x9c761(%rip), %r14     # 0xa3283
leaq 0x9c198(%rip), %rbx     # 0xa2cc1
movl %ebp, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x6a6a
movl %eax, 0xc(%rsp)
testl %ebp, %ebp
jle 0x6b71
xorl %ebp, %ebp
movl (%r12,%rbp,4), %eax
movq %r14, %rdi
testl %eax, %eax
je 0x6b57
cmpl $0x1, %eax
jne 0x6b69
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
incq %rbp
cmpq %rbp, %r13
jne 0x6b44
testb $0x1, 0xc(%rsp)
leaq 0x9f7ac(%rip), %rdi     # 0xa6329
leaq 0xa1dc8(%rip), %rax     # 0xa894c
cmovneq %rax, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
movq %r12, %rdi
movl 0x8(%rsp), %ebp
movl %ebp, %esi
movl $0x1, %edx
callq 0x38bb6
testl %eax, %eax
jne 0x6b2d
movq %r12, %rdi
callq 0x39194
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x9c0ea(%rip), %rdi     # 0xa2cc4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/binary.c
// Function: generate_random_noisy_data_from_binary_function
void generate_random_noisy_data_from_binary_function(Binaryfunctionptr bf, int d, double p, char* fname)
{
 /*!Last Changed 21.04.2008*/
 FILE* outfile;
 int* iterator;
 int result, i;
 outfile = fopen(fname, "w");
 if (!outfile)
  {
   printf(m1306);
   return;
  }
 iterator = first_iterator(d);
 do{
   result = evaluate_binary_function(bf, iterator);
   for (i = 0; i < d; i++)
     switch (iterator[i])
      {
       case BOOLEAN_FALSE:fprintf(outfile, "F ");
                          break;
       case  BOOLEAN_TRUE:fprintf(outfile, "T ");
                          break;
      }
   if (produce_random_value(0.0, 1.0) < p)
     result = 1 - result;
   switch (result)
    {
     case BOOLEAN_FALSE:fprintf(outfile, "F\n");
                        break;
     case  BOOLEAN_TRUE:fprintf(outfile, "T\n");
                        break;
    }
 }while(next_iterator(iterator, d, 1));
 safe_free(iterator);
 fclose(outfile);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, 0x8(%rsp)
leaq 0xa1c92(%rip), %rsi     # 0xa88a1
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x6d05
movq %rax, %r15
movl %ebp, %edi
callq 0x38632
movq %rax, %r12
movl %ebp, %r13d
leaq 0x9c64c(%rip), %r14     # 0xa3283
leaq 0x9c083(%rip), %rbx     # 0xa2cc1
movl %ebp, (%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x6a6a
movl %eax, 0x4(%rsp)
testl %ebp, %ebp
jle 0x6c85
xorl %ebp, %ebp
movl (%r12,%rbp,4), %eax
movq %r14, %rdi
testl %eax, %eax
je 0x6c6b
cmpl $0x1, %eax
jne 0x6c7d
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
incq %rbp
cmpq %rbp, %r13
jne 0x6c58
xorpd %xmm0, %xmm0
movsd 0x9b88f(%rip), %xmm1    # 0xa2520
callq 0x39f62
xorl %eax, %eax
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
cmpl %eax, 0x4(%rsp)
leaq 0xa1c9c(%rip), %rdi     # 0xa894c
leaq 0x9f672(%rip), %rax     # 0xa6329
cmoveq %rax, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
movq %r12, %rdi
movl (%rsp), %ebp
movl %ebp, %esi
movl $0x1, %edx
callq 0x38bb6
testl %eax, %eax
jne 0x6c41
movq %r12, %rdi
callq 0x39194
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x9bfb8(%rip), %rdi     # 0xa2cc4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/cart.c
// Function: create_cartchildren
int create_cartchildren(Decisionnodeptr node, C45_parameterptr param)
{
 node->conditiontype = MULTIVARIATE_CONDITION;
 if (!(can_be_divided(node, param)))
   return 1;
 if (!find_best_cart_split(node))
  {
   make_leaf_node(node);
   return 1;
  }
 node->lineard = current_dataset->multifeaturecount - 1;
 node->featureno = LINEAR; 
 if (!(make_multivariate_children(node)))
   return 1;
 create_cartchildren(node->left, param);
 create_cartchildren(node->right, param);
 return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0xcb6f4(%rip), %r12     # 0xd2870
movl $0x1, %r13d
movl $0x1, 0x98(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c8e2
testl %eax, %eax
je 0x71f0
movq %rbx, %rdi
callq 0x6d20
testl %eax, %eax
je 0x71e8
movq (%r12), %rax
movl 0x1c0(%rax), %eax
decl %eax
movl %eax, 0x90(%rbx)
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
movq %rbx, %rdi
callq 0x4c6b9
testl %eax, %eax
je 0x71f0
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x7161
movq 0x8(%rbx), %rbx
testb $0x1, %r15b
cmovel %r13d, %ebp
movb $0x1, %r15b
jmp 0x7182
movq %rbx, %rdi
callq 0x1c39c
testb $0x1, %r15b
movl $0x1, %eax
cmovnel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/c45rules.c
// Function: sort_rules
void sort_rules(Ruleset* r)
{
 /*!Last Changed 05.11.2003 If i is r->end then after exchange j will be  r->end*/
 /*!Last Changed 30.10.2003*/
 Decisionruleptr i;
 Decisionruleptr j;
 Decisionruleptr ibefore;
 Decisionruleptr tmp;
 Decisionruleptr jbefore;
 if (r->start == NULL)
   return;
 for (ibefore = r->start, i = r->start->next; i != NULL; ibefore = i, i = i->next)
   for (jbefore = NULL, j = r->start; j != i; jbefore = j, j = j->next)
     if (j->classno > i->classno)
      {
       ibefore->next = j;
       if (jbefore)
         jbefore->next = i;
       else
         r->start = i;
       if (i->next == NULL)
         r->end = j;
       tmp = j->next;
       j->next = i->next;
       i->next = tmp;
       break;
      }
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x7287
movq 0x30(%rcx), %rax
testq %rax, %rax
je 0x7287
addq $0x30, %rcx
movq (%rdi), %rdx
cmpq %rax, %rdx
je 0x7274
movl (%rax), %esi
cmpl %esi, (%rdx)
jle 0x7234
xorl %r9d, %r9d
jmp 0x724a
movq %rdx, %r8
movq 0x30(%r8), %rdx
cmpq %rax, %rdx
je 0x7274
movq %r8, %r9
movq %rdx, %r8
cmpl %esi, (%rdx)
jle 0x7237
leaq 0x30(%r9), %rsi
testq %r9, %r9
cmoveq %rdi, %rsi
movq %rdx, (%rcx)
movq %rax, (%rsi)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
jne 0x7268
movq %rdx, 0x8(%rdi)
movq 0x30(%rdx), %rsi
movq %rcx, 0x30(%rdx)
movq %rsi, 0x30(%rax)
movq %rax, %rcx
movq 0x30(%rax), %rdx
addq $0x30, %rcx
movq %rdx, %rax
testq %rdx, %rdx
jne 0x7221
retq
// File: /workspace/github_c_makefile_star2_O1/olcaytaner[P]Isell/c45rules.c
// Function: create_subset_of_ruleset
void create_subset_of_ruleset(Ruleset* result, Decisionruleptr* rules, int* subset, int subsetcount)
{
 /*!Last Changed 30.10.2003*/
 int i;
 result->start = NULL;
 result->end = NULL;
 result->rulecount = subsetcount;
 if (subsetcount == 0)
   return;
 result->start = rules[subset[0]];
 result->end = rules[subset[subsetcount-1]];
 result->end->next = NULL;
 for (i = 0; i < subsetcount - 1; i++)
   rules[subset[i]]->next = rules[subset[i + 1]];
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl %ecx, 0x10(%rdi)
testl %ecx, %ecx
je 0x750c
movslq (%rdx), %rax
movq (%rsi,%rax,8), %rax
movq %rax, (%rdi)
movslq %ecx, %rax
movslq -0x4(%rdx,%rax,4), %rax
movq (%rsi,%rax,8), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x30(%rax)
cmpl $0x2, %ecx
jl 0x750c
decl %ecx
movl %ecx, %eax
xorl %ecx, %ecx
movslq 0x4(%rdx,%rcx,4), %rdi
movslq (%rdx,%rcx,4), %r8
leaq 0x1(%rcx), %r9
movq (%rsi,%rdi,8), %rcx
movq (%rsi,%r8,8), %rdi
movq %rcx, 0x30(%rdi)
movq %r9, %rcx
cmpq %r9, %rax
jne 0x74eb
retq