LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x38(%rdi), %esi
testl %esi, %esi
jle 0x5841
movq 0x48(%rbx), %r12
leaq 0x5d45(%rip), %rdi      # 0xb54e
movq %rdi, %rdx
callq 0x5939
leaq 0x60ab(%rip), %rcx      # 0xb8c3
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x427d
leaq 0x6584(%rip), %rsi      # 0xbdb1
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
je 0x5841
movq %rax, %r12
xorl %ebp, %ebp
jmp 0x5879
movq 0x48(%rbx), %rdi
leaq 0x5d02(%rip), %rsi      # 0xb54e
leaq 0x6070(%rip), %rcx      # 0xb8c3
movq %r15, %rdx
callq 0x427d
leaq 0x654f(%rip), %rsi      # 0xbdb1
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
je 0x5911
movq %rax, %r12
movb $0x1, %bpl
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x5923
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x592e
movl 0x8(%rsp), %ecx
testl %ecx, %ecx
je 0x58d0
xorl %eax, %eax
testl %ecx, %ecx
jg 0x58d5
movq %r15, %rdi
movq %r12, %rsi
callq 0x1880
movl $0x1, %eax
movl %eax, (%r14)
movq %r12, %rdi
callq 0x10c0
testb %bpl, %bpl
je 0x58eb
leaq 0x4(%rbx), %rcx
jmp 0x58f7
movq 0x60(%rbx), %rcx
leaq -0x4(%rcx), %rbx
addq $-0x8, %rcx
movl 0xc(%rsp), %edx
xorl %eax, %eax
cmpl (%rbx), %edx
je 0x5916
xorl %eax, %eax
cmpl (%rcx), %edx
sete %al
leal -0x1(,%rax,2), %eax
jmp 0x5916
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r12, %rsi
callq 0x1814
movq %r15, %rdi
movq %r12, %rsi
callq 0x184a
// File: /workspace/github_c_makefile_star2_O3/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 0x581f(%rip), %rsi      # 0xba24
callq 0x2af5
testq %rax, %rax
je 0x6211
popq %rcx
retq
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O3/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 0x62b9
cmpl %esi, 0x14(%rdi)
jle 0x62b9
movq %rdx, %rbx
cmpl $0x4, 0x10(%rdi)
movq 0x18(%rdi), %rcx
movl %esi, %eax
jne 0x6249
movslq (%rcx,%rax,4), %r12
jmp 0x624d
movq (%rcx,%rax,8), %r12
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %r15
movslq (%rcx,%rax,4), %r14
cmpl $0x0, 0x30(%rdi)
je 0x6272
addq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1060
jmp 0x62aa
movq %r15, %rdi
callq 0x1080
cmpq %r12, %rax
je 0x628c
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1230
testl %r14d, %r14d
jle 0x62aa
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x10b0
cmpq $0x1, %rax
jne 0x62be
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_O3/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 0x690e
leaq 0x4(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x6913
leaq 0x8(%rbx), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1280
cmpq $0x1, %rax
jne 0x6918
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 0x691d
movq 0x10(%rbx), %rdi
movslq 0xc(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1280
cmpq %r15, %rax
jne 0x6922
movq 0x18(%rbx), %rdi
movslq 0x4(%rbx), %rdx
movl $0x8, %esi
movq %r14, %rcx
callq 0x1280
movslq 0x4(%rbx), %rcx
cmpq %rcx, %rax
jne 0x6927
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_O3/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 0x47f0(%rip), %r15      # 0xbd9a
movq %r15, %rsi
callq 0x2af5
movq %rax, %rbx
movl $0x28, %edi
movq %r15, %rsi
callq 0x2af5
testq %rbx, %rbx
je 0x75e8
testq %rax, %rax
je 0x75e8
movslq 0x20(%r14), %rcx
xorl %edx, %edx
movq %rbx, (%rax,%rdx,8)
incq %rdx
addq %rcx, %rbx
cmpq $0x5, %rdx
jne 0x75d2
popq %rbx
popq %r14
popq %r15
retq
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O3/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, 0xb302(%rip)      # 0x12910
je 0x7644
movq 0x68(%r15), %r12
testq %r12, %r12
je 0x7729
movq 0x8(%r12), %rdi
leaq 0x403a(%rip), %rsi      # 0xb663
callq 0x1190
testl %eax, %eax
jne 0x7729
movq %r12, 0xb2db(%rip)      # 0x12918
movq %r15, 0xb2cc(%rip)      # 0x12910
testl %ebp, %ebp
js 0x7724
cmpl %ebp, 0x30(%r15)
jle 0x7724
movq 0x60(%r15), %rax
movq 0xb2b7(%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 0xb28a(%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 0x9a0e
testl %eax, %eax
jne 0x772e
cmpl $0x1, %ebx
je 0x7713
movq 0x8(%r14), %rax
cmpl $0x2, %ebx
jne 0x76d7
testl %r15d, %r15d
jle 0x7713
xorl %ecx, %ecx
addb $-0x20, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r15
jne 0x76c9
jmp 0x7713
movslq %r15d, %rcx
movb (%rax,%rcx), %dl
movb $0x0, (%rax,%rcx)
movb (%rax), %sil
movq %rax, %rdi
testb %sil, %sil
je 0x770d
leaq 0x490d(%rip), %r8       # 0xc000
movq %rax, %rdi
movsbq %sil, %rsi
movb (%rsi,%r8), %sil
movb %sil, (%rdi)
movb 0x1(%rdi), %sil
incq %rdi
testb %sil, %sil
jne 0x76f6
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 0x1dd2
callq 0x1daa
movl $0x1, %edi
callq 0x1270
// File: /workspace/github_c_makefile_star2_O3/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 0x7754
cmpl 0x4(%rbx), %esi
setl %al
jmp 0x77a0
cmpl 0x4(%rbx), %esi
jge 0x779e
movq 0x10(%rbx), %rdx
testl %esi, %esi
js 0x7775
incl %esi
movq 0x20(%rbx), %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x5939
movq %rax, %rdx
movq 0x18(%rbx), %rdi
leaq 0x3d6e(%rip), %rsi      # 0xb4ee
leaq 0x4682(%rip), %rcx      # 0xbe09
callq 0x427d
movq %rsp, %rsi
movq %rax, %rdi
callq 0x11c0
testl %eax, %eax
sete %al
jmp 0x77a0
xorl %eax, %eax
movzbl %al, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7820
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal 0x1(%rax), %esi
movl %esi, 0x8(%rdi)
cmpl 0x4(%rdi), %eax
jge 0x7816
movq 0x10(%rbx), %r14
cmpl $-0x1, %eax
jl 0x77df
movq 0x20(%rbx), %rdx
movq %r14, %rdi
callq 0x5939
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x3d04(%rip), %rsi      # 0xb4ee
leaq 0x4618(%rip), %rcx      # 0xbe09
movq %r14, %rdx
callq 0x427d
leaq 0x45b1(%rip), %rsi      # 0xbdb1
movq %rax, %rdi
callq 0x1240
testq %rax, %rax
jne 0x7818
cmpl $0x7fffffff, 0x4(%rbx)  # imm = 0x7FFFFFFF
jne 0x7825
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1dfa
movq %r14, %rdi
callq 0x1e22
// File: /workspace/github_c_makefile_star2_O3/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 0x787f
pushq %rax
movq 0x20(%rax), %rdx
callq 0x5939
movq %rax, %rdi
addq $0x8, %rsp
leaq 0x45f0(%rip), %rsi      # 0xbe76
jmp 0x2bb2
// File: /workspace/github_c_makefile_star2_O3/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 0x7904
movq 0x18(%rbx), %rdi
callq 0x10e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x7860
movq %rax, %rdi
callq 0x10e0
addl %r15d, %eax
addl $0x1e, %eax
movslq %eax, %rdi
leaq 0x4599(%rip), %rsi      # 0xbe8c
callq 0x2af5
movq %rax, %rdi
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x7970
movl 0x4(%rbx), %eax
movl 0x8(%rbx), %r9d
movl %eax, %r15d
subl %r9d, %r15d
jle 0x7950
leal (%r9,%r14), %ecx
cmpl %eax, %ecx
cmovlel %r14d, %r15d
cmpl $0x0, (%rbx)
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
js 0x7954
leal (%r15,%r9), %r10d
incl %r9d
leaq 0x456f(%rip), %rsi      # 0xbea7
movl $0x40, %r8d
xorl %eax, %eax
pushq 0x20(%rbx)
pushq %r10
callq 0x1260
addq $0x10, %rsp
jmp 0x7962
xorl %eax, %eax
jmp 0x796a
leaq 0x4546(%rip), %rsi      # 0xbea1
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_O3/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
movq 0xac5b(%rip), %rdi      # 0x12930
testq %rdi, %rdi
je 0x7ce2
movl 0x84d8(%rip), %esi      # 0x101b8
jmp 0x7d15
leaq 0x44cf(%rip), %rsi      # 0xc1b8
movl $0x1388, %edi           # imm = 0x1388
callq 0x2af5
testq %rax, %rax
je 0x7e11
movq %rax, %rdi
movl $0x3e8, 0x84af(%rip)    # imm = 0x3E8
movq %rax, 0xac20(%rip)      # 0x12930
movl $0x3e8, %esi            # imm = 0x3E8
incl 0xac1d(%rip)            # 0x12938
movq %r14, %rdx
callq 0x1180
testq %rax, %rax
je 0x7df9
movq 0xabfd(%rip), %r12      # 0x12930
movq %r12, %rdi
callq 0x10e0
movq %rax, %r15
movslq %r15d, %r13
cmpb $0xa, -0x1(%r12,%r13)
je 0x7dbc
movslq 0x8468(%rip), %r13      # 0x101b8
addq $0x3e8, %r13            # imm = 0x3E8
leaq (,%r13,4), %rsi
addq %r13, %rsi
movq %r12, %rdi
leaq 0x446c(%rip), %rdx      # 0xc1d8
callq 0x2b4d
testq %rax, %rax
je 0x7e11
movl %r13d, 0x8437(%rip)     # 0x101b8
movq %rax, 0xaba8(%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 0x7e1b
movq 0xab85(%rip), %r12      # 0x12930
leaq (%r12,%rbp), %rdi
callq 0x10e0
movq %rax, %r15
addq %rbp, %r15
jmp 0x7d3e
decq %r13
cmpl $0x2, %ebx
jl 0x7dff
decl %ebx
movslq 0x83eb(%rip), %rsi      # 0x101b8
addq %rsi, %r12
incl 0xab62(%rip)            # 0x12938
movq %r12, %rdi
movq %r14, %rdx
callq 0x1180
testq %rax, %rax
je 0x7e20
movq %r12, %rdi
callq 0x10e0
cmpl %eax, %r15d
jne 0x7e25
decl %ebx
jne 0x7dc6
jmp 0x7dff
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 0x1f53
callq 0x1fa1
callq 0x1f7a
// File: /workspace/github_c_makefile_star2_O3/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 0x8086
pushq %rbx
leaq 0x7f8(%rdi), %rax
movl %edx, %r8d
xorl %r9d, %r9d
movslq %r9d, %r11
leal 0x1(%r11), %r10d
cmpl %r10d, %edx
cmovgl %edx, %r10d
movzbl (%rsi,%r11), %ebx
cmpl %ecx, %ebx
jne 0x8054
incq %r11
cmpq %r8, %r11
jl 0x8041
jmp 0x8057
movl %r11d, %r10d
xorl %r11d, %r11d
cmpl %ecx, %ebx
setne %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
cmpl %edx, %r11d
jl 0x8033
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8bb9
cmpl $0x0, 0x30(%r14)
js 0x8b70
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x8bb9
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x8bb9
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x8bb9
movq 0x18(%r14), %rdi
movq %rbx, %rsi
callq 0x8bb9
cmpl $0x0, 0x34(%r14)
js 0x8bae
movq 0x28(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8bb9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9086
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 0x90b0
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_O3/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 0x914c
movq 0x20(%r14), %rsi
movq %rdx, 0x18(%rsp)
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x9426
testl %ebp, %ebp
jle 0x9160
movl 0x30(%r14), %eax
movl %ebp, %r8d
movl %ebp, %ecx
xorl %edx, %edx
xorl %ebp, %ebp
movsbl (%rbx,%rdx), %esi
cmpl %esi, %eax
je 0x9142
movb (%r13,%rdx), %sil
movslq %ebp, %rdi
incl %ebp
movb %sil, (%r13,%rdi)
incq %rdx
cmpq %rdx, %rcx
jne 0x912b
jmp 0x9165
movq %rdx, %r14
movq %rdx, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x9238
movl %ebp, %ebx
jmp 0x9176
movl %ebp, %r8d
xorl %ebp, %ebp
movslq %ebp, %rax
movb $0x0, (%r13,%rax)
movl %r8d, %ebx
movq 0x18(%rsp), %r14
movq %r13, %rdi
callq 0x33ec
movl %ebp, %edi
movq %r13, %rsi
callq 0x32af
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 0x91c8
movl %ebx, %eax
xorl %ecx, %ecx
andb $-0x2, (%r12,%rcx)
andb $-0x4, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x91b6
movq 0x20(%rsp), %r13
movq 0x8(%r13), %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x9238
movq 0x10(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x9238
movl 0x34(%r13), %r9d
movq 0x18(%r13), %rdi
testl %r9d, %r9d
js 0x921e
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 0x9426
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 0x9238
// File: /workspace/github_c_makefile_star2_O3/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:
leal (%rdi,%rdi), %ecx
cmpl %edx, %ecx
jg 0xa57d
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %eax
movq (%rsi,%rax,8), %rax
movl %edi, %r8d
movslq %ecx, %r9
movq (%rsi,%r9,8), %r9
cmpl %edx, %ecx
jge 0xa545
movl %ecx, %ebx
orl $0x1, %ebx
movslq %ebx, %r10
movq (%rsi,%r10,8), %r15
movq 0x10(%r15), %r14
movq 0x10(%r9), %r11
movq 0x10(%rax), %r10
cmpq %r11, %r14
ja 0xa54d
movq %r15, %r9
movl %ebx, %ecx
cmpq %r14, %r10
ja 0xa552
jmp 0xa569
movq 0x10(%rax), %r10
movq 0x10(%r9), %r11
cmpq %r11, %r10
jbe 0xa569
movl %ecx, %r10d
movslq %r8d, %rcx
movq %r9, (%rsi,%rcx,8)
leal (%r10,%r10), %ecx
movl %r10d, %r8d
cmpl %edx, %ecx
jle 0xa511
jmp 0xa56c
movl %r8d, %r10d
cmpl %edi, %r10d
je 0xa578
movslq %r10d, %rcx
movq %rax, (%rsi,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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(%rdi)
je 0xa5c7
leal (%r15,%r15), %esi
incl %ebp
movq (%r12), %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0xa57e
movq 0x8(%r12), %r12
leal 0x1(,%r15,2), %r15d
cmpq $0x0, 0x8(%r12)
jne 0xa59b
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_O3/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 0x3aa8c
movl 0x140713c(%rbx), %ecx
testl %eax, %eax
je 0x459f
cmpl $0x2, %ecx
je 0x45db
leaq 0xa15da(%rip), %rdi     # 0xa5b74
jmp 0x4623
cmpl $0x3, %ecx
jne 0x45db
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 0x3aa8c
addq $0x10, %rsp
testl %eax, %eax
je 0x461c
leal -0x3e8(%r14), %eax
cmpl $0x29, %eax
jae 0x45fb
movl $0x1, %eax
cmpl $0x0, 0x10(%rbx)
jne 0x462a
leaq 0xa1546(%rip), %rdi     # 0xa5b3f
jmp 0x4623
addl $0xfffff830, %r14d      # imm = 0xFFFFF830
movl $0x1, %eax
cmpl $0x11, %r14d
jae 0x462a
cmpl $0x0, 0x10(%rbx)
je 0x462a
leaq 0xa14f0(%rip), %rdi     # 0xa5b0a
jmp 0x4623
leaq 0xa147b(%rip), %rdi     # 0xa5a9e
callq 0x4090
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcf765(%rip), %r12     # 0xd41c0
movq 0x9c50(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x3b3a8
testl %eax, %eax
je 0x4ab5
incl %ebx
addq $0x28, %r15
cmpq $0x668, %r15            # imm = 0x668
jne 0x4a5b
movl $0x7d0, %ebx            # imm = 0x7D0
xorl %r15d, %r15d
leaq 0xcfda3(%rip), %r12     # 0xd4830
movq 0x13890(%r15,%r12), %rsi
movq %r14, %rdi
callq 0x3b3a8
testl %eax, %eax
je 0x4ab5
incl %ebx
addq $0x28, %r15
cmpq $0x2a8, %r15            # imm = 0x2A8
jne 0x4a8d
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_O3/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 0x9f4a7(%rip), %rsi     # 0xa5cab
movl $0x10, %edi
movl $0x2, %edx
callq 0x3a0e1
movl $0x0, 0x8(%rax)
movq $0x0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a180
movq (%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x3a180
incq %r15
movslq 0x8(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x6837
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3a180
// File: /workspace/github_c_makefile_star2_O3/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 0x6ad4
pushq %rbx
movq (%rdi), %rcx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %r9
movslq 0x10(%rcx,%r9,8), %rdi
movl $0x0, %r8d
testq %rdi, %rdi
jle 0x6abc
leaq (%rcx,%r9,8), %r8
movq (%r8), %r9
movq 0x8(%r8), %r10
xorl %r8d, %r8d
movslq (%r9,%r8,4), %r11
cmpl $0x0, (%rsi,%r11,4)
setne %r11b
cmpl $0x0, (%r10,%r8,4)
setne %bl
cmpb %r11b, %bl
je 0x6abc
incq %r8
cmpq %r8, %rdi
jne 0x6a98
jmp 0x6acd
cmpl %edi, %r8d
je 0x6acd
incq %rdx
cmpq %rax, %rdx
jne 0x6a76
xorl %eax, %eax
jmp 0x6ad2
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa4e7a(%rip), %rsi     # 0xab96d
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x6bcc
movq %rax, %r15
movl %ebp, %edi
callq 0x3930e
movq %rax, %r12
movl %ebp, %r13d
leaq 0x9f768(%rip), %r14     # 0xa6283
leaq 0x9f19f(%rip), %rbx     # 0xa5cc1
movl %ebp, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x6a67
movl %eax, 0xc(%rsp)
testl %ebp, %ebp
jle 0x6b6a
xorl %ebp, %ebp
movl (%r12,%rbp,4), %eax
movq %r14, %rdi
testl %eax, %eax
je 0x6b50
cmpl $0x1, %eax
jne 0x6b62
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
incq %rbp
cmpq %rbp, %r13
jne 0x6b3d
testb $0x1, 0xc(%rsp)
leaq 0xa27e1(%rip), %rdi     # 0xa9357
leaq 0xa4e9b(%rip), %rax     # 0xaba18
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 0x3991a
testl %eax, %eax
jne 0x6b26
movq %r12, %rdi
callq 0x3a180
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x9f0f1(%rip), %rdi     # 0xa5cc4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 0xa4d65(%rip), %rsi     # 0xab96d
movq %rdx, %rdi
callq 0x40f0
testq %rax, %rax
je 0x6cfe
movq %rax, %r15
movl %ebp, %edi
callq 0x3930e
movq %rax, %r12
movl %ebp, %r13d
leaq 0x9f653(%rip), %r14     # 0xa6283
leaq 0x9f08a(%rip), %rbx     # 0xa5cc1
movl %ebp, (%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x6a67
movl %eax, 0x4(%rsp)
testl %ebp, %ebp
jle 0x6c7e
xorl %ebp, %ebp
movl (%r12,%rbp,4), %eax
movq %r14, %rdi
testl %eax, %eax
je 0x6c64
cmpl $0x1, %eax
jne 0x6c76
movq %rbx, %rdi
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x42c0
incq %rbp
cmpq %rbp, %r13
jne 0x6c51
xorpd %xmm0, %xmm0
movsd 0x9e896(%rip), %xmm1    # 0xa5520
callq 0x3af6a
xorl %eax, %eax
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
cmpl %eax, 0x4(%rsp)
leaq 0xa4d6f(%rip), %rdi     # 0xaba18
leaq 0xa26a7(%rip), %rax     # 0xa9357
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 0x3991a
testl %eax, %eax
jne 0x6c3a
movq %r12, %rdi
callq 0x3a180
movq %r15, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42a0
leaq 0x9efbf(%rip), %rdi     # 0xa5cc4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4090
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0x98(%rdi)
callq 0x1d053
testl %eax, %eax
je 0x71e2
leaq 0xce6f0(%rip), %r15     # 0xd5870
movq %rbx, %rdi
callq 0x6d18
testl %eax, %eax
je 0x71da
movq (%r15), %rax
movl 0x1c0(%rax), %eax
decl %eax
movl %eax, 0x90(%rbx)
movl $0xfffffffe, 0x30(%rbx) # imm = 0xFFFFFFFE
movq %rbx, %rdi
callq 0x4db5c
testl %eax, %eax
je 0x71e2
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x715b
movq 0x8(%rbx), %rbx
movl $0x1, 0x98(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d053
testl %eax, %eax
jne 0x7180
jmp 0x71e2
movq %rbx, %rdi
callq 0x1cab0
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x726b
movq 0x30(%rcx), %rax
testq %rax, %rax
je 0x726b
addq $0x30, %rcx
movq (%rdi), %rdx
cmpq %rax, %rdx
je 0x7258
movl (%rax), %esi
cmpl %esi, (%rdx)
jle 0x7218
xorl %r9d, %r9d
jmp 0x722e
movq %rdx, %r8
movq 0x30(%r8), %rdx
cmpq %rax, %rdx
je 0x7258
movq %r8, %r9
movq %rdx, %r8
cmpl %esi, (%rdx)
jle 0x721b
leaq 0x30(%r9), %rsi
testq %r9, %r9
cmoveq %rdi, %rsi
movq %rdx, (%rcx)
movq %rax, (%rsi)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
jne 0x724c
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 0x7205
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x74eb
movslq (%rdx), %r8
movq (%rsi,%r8,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 0x74eb
decl %ecx
movl %ecx, %eax
movq (%rsi,%r8,8), %rdi
xorl %ecx, %ecx
movslq 0x4(%rdx,%rcx,4), %r8
incq %rcx
movq (%rsi,%r8,8), %r8
movq %r8, 0x30(%rdi)
movq %r8, %rdi
cmpq %rcx, %rax
jne 0x74d3
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/c45rules.c
// Function: remove_rules_according_indexes_of_rule
void remove_rules_according_indexes_of_rule(Decisionruleptr* rules, int rulecount, int* subset, int subsetcount)
{
 /*!Last Changed 02.12.2004*/
 int i, j;
 BOOLEAN found;
 for (i = 0; i < rulecount; i++)
  {
   found = BOOLEAN_FALSE;
   for (j = 0; j < subsetcount; j++)
     if (subset[j] == i)
      {
       found = BOOLEAN_TRUE;
       break;
      }
   if (!found)
    {
     free_rule(*(rules[i]));
     safe_free(rules[i]);
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x756f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r12d
movl %ecx, %r13d
xorl %ebp, %ebp
testl %ebx, %ebx
jle 0x7525
xorl %eax, %eax
movl (%r14,%rax,4), %ecx
cmpq %rcx, %rbp
je 0x7559
incq %rax
cmpq %rax, %r13
jne 0x7514
movq (%r15,%rbp,8), %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x7c251
movq (%r15,%rbp,8), %rdi
callq 0x3a180
incq %rbp
cmpq %r12, %rbp
jne 0x750e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/c45rules.c
// Function: remove_rules_according_rules_themselves
void remove_rules_according_rules_themselves(Decisionruleptr* rules, int rulecount, Decisionruleptr* subsetrules, int subsetcount)
{
 /*!Last Changed 02.12.2004*/
 int i, j;
 BOOLEAN found;
 for (i = 0; i < rulecount; i++)
  {
   found = BOOLEAN_FALSE;
   for (j = 0; j < subsetcount; j++)
     if (rules[i] == subsetrules[j])
      {
       found = BOOLEAN_TRUE;
       break;
      }
   if (!found)
    {
     free_rule(*(rules[i]));
     safe_free(rules[i]);
    }
  }
}

// Assembly:
testl %esi, %esi
jle 0x75f0
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %r12d
movl %ecx, %r13d
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rax
testl %ebx, %ebx
jle 0x75aa
xorl %ecx, %ecx
cmpq (%r14,%rcx,8), %rax
je 0x75da
incq %rcx
cmpq %rcx, %r13
jne 0x759c
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x7c251
movq (%r15,%rbp,8), %rdi
callq 0x3a180
incq %rbp
cmpq %r12, %rbp
jne 0x7592
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/olcaytaner[P]Isell/c45rules.c
// Function: check_all_subsets
Ruleset check_all_subsets(Decisionruleptr start, int rulecount, Instanceptr traindata, int conditioncount)
{
 /*!Last Changed 02.12.2004 added remove_rules_according_indexes_of_rule*/
 /*!Last Changed 30.10.2003*/
 Ruleset result;
 Decisionruleptr* rules;
 int **subsets, *counts, res, i, minindex = -1;
 double minlength = +1000000, length;
 empty_ruleset(&result);
 result.possibleconditioncount = conditioncount;
 rules = create_array_from_link_list_of_rules(start, rulecount);
 subsets = generate_subsets(rulecount, &res, &counts);
 for (i = 0; i < res; i++)
  {
   create_subset_of_ruleset(&result, rules, subsets[i], counts[i]);
   length = description_length_of_all(result, rules[0]->classno, 1, traindata);
   if (dless(length,minlength))
    {
     minlength = length;
     minindex = i;
    }
  }
 create_subset_of_ruleset(&result, rules, subsets[minindex], counts[minindex]);
 remove_rules_according_indexes_of_rule(rules, rulecount, subsets[minindex], counts[minindex]);
 for (i = 0; i < res; i++) 
   if (counts[i] > 0)
     safe_free(subsets[i]);
 safe_free(subsets);
 safe_free(counts);
 safe_free(rules);
 return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r8d, %r14d
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7c32b
movl %r14d, 0x20(%rbx)
movq %r15, %rdi
movl %ebp, %esi
callq 0x7774
movq %rax, %r14
leaq 0x34(%rsp), %r13
leaq 0x38(%rsp), %rdx
movl %ebp, %edi
movq %r13, %rsi
callq 0x3971c
movq %rax, %r15
cmpl $0x0, (%r13)
jle 0x76e3
movl %ebp, 0x44(%rsp)
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movsd 0x9e6ca(%rip), %xmm0    # 0xa5d20
movsd %xmm0, 0x48(%rsp)
xorl %r13d, %r13d
movl %ecx, %ebp
movq (%r15,%r13,8), %rdx
movq 0x38(%rsp), %rax
movl (%rax,%r13,4), %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7495
movq (%r14), %rax
movl (%rax), %edi
movq 0x20(%rbx), %rax
movq %rax, 0x20(%rsp)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl $0x1, %esi
movq %r12, %rdx
xorl %eax, %eax
callq 0x726c
movsd %xmm0, 0x50(%rsp)
movsd 0x48(%rsp), %xmm1
callq 0x39aee
movl %r13d, %ecx
testl %eax, %eax
cmovel %ebp, %ecx
je 0x76cd
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x48(%rsp)
incq %r13
movslq 0x34(%rsp), %rax
cmpq %rax, %r13
jl 0x765f
movslq %ecx, %r12
movl 0x44(%rsp), %ebp
jmp 0x76ea
movq $-0x1, %r12
movq (%r15,%r12,8), %rdx
movq 0x38(%rsp), %rax
movl (%rax,%r12,4), %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7495
movq (%r15,%r12,8), %rdx
movq 0x38(%rsp), %rax
movl (%rax,%r12,4), %ecx
movq %r14, %rdi
movl %ebp, %esi
callq 0x74ec
movl 0x34(%rsp), %eax
testl %eax, %eax
jle 0x7748
xorl %r12d, %r12d
movq 0x38(%rsp), %rcx
cmpl $0x0, (%rcx,%r12,4)
jle 0x773d
movq (%r15,%r12,8), %rdi
callq 0x3a180
movl 0x34(%rsp), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x7724
movq %r15, %rdi
callq 0x3a180
movq 0x38(%rsp), %rdi
callq 0x3a180
movq %r14, %rdi
callq 0x3a180
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq