LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x7615
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jl 0x763e
movq 0xa9dc(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xd462(%rip), %rdx      # 0x14a88
leaq 0x73bb(%rip), %rsi      # 0xe9e8
movb $0x0, %al
callq 0x1180
movl $0x1, %edi
callq 0x1260
movq -0x10(%rbp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x765e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movslq (%rax,%rcx,4), %rax
movq %rax, -0x30(%rbp)
jmp 0x7672
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x76af
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
addq -0x30(%rbp), %rsi
movslq -0x34(%rbp), %rdx
callq 0x1050
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x772c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1070
cmpq -0x30(%rbp), %rax
je 0x76d9
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x1220
cmpl $0x0, -0x34(%rbp)
jle 0x7726
movq -0x20(%rbp), %rdi
movslq -0x34(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x1, %edx
callq 0x10a0
cmpq $0x1, %rax
je 0x7724
movq 0xa8f6(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xd37c(%rip), %rdx      # 0x14a88
leaq 0x7300(%rip), %rsi      # 0xea13
movb $0x0, %al
callq 0x1180
movl $0x1, %edi
callq 0x1260
jmp 0x7726
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1270
cmpq $0x1, %rax
je 0x8106
movq 0x9f14(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xc99a(%rip), %rdx      # 0x14a88
leaq 0x6b3d(%rip), %rsi      # 0xec32
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1270
cmpq $0x1, %rax
je 0x8150
movq 0x9eca(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xc950(%rip), %rdx      # 0x14a88
leaq 0x6af3(%rip), %rsi      # 0xec32
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1270
cmpq $0x1, %rax
je 0x819a
movq 0x9e80(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xc906(%rip), %rdx      # 0x14a88
leaq 0x6aa9(%rip), %rsi      # 0xec32
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x10d0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x14(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1270
cmpq $0x1, %rax
je 0x81f0
movq 0x9e2a(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xc8b0(%rip), %rdx      # 0x14a88
leaq 0x6a53(%rip), %rsi      # 0xec32
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1270
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x823c
movq 0x9dde(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xc864(%rip), %rdx      # 0x14a88
leaq 0x6a07(%rip), %rsi      # 0xec32
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x8, %esi
callq 0x1270
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
je 0x8290
movq 0x9d8a(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xc810(%rip), %rdx      # 0x14a88
leaq 0x69b3(%rip), %rsi      # 0xec32
movb $0x0, %al
callq 0x1180
movl $0x2, %edi
callq 0x1260
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
imull $0x5, 0x20(%rax), %eax
movslq %eax, %rdi
leaq 0x606f(%rip), %rsi      # 0xed3d
callq 0x22c0
movq %rax, -0x18(%rbp)
movl $0x28, %edi
leaq 0x605a(%rip), %rsi      # 0xed3d
callq 0x22c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8cfa
cmpq $0x0, -0x10(%rbp)
jne 0x8d04
movl $0x1, %edi
callq 0x1260
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0x8d3c
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x20(%rcx), %eax
cltq
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8d0b
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DB.c
// Function: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x8f9c
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x8f90
movl $0x0, -0x4(%rbp)
jmp 0x9036
movl $0x1, -0x4(%rbp)
jmp 0x9036
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x8fb8
movl $0x0, -0x4(%rbp)
jmp 0x9036
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x8fd0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8ff3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
addl $0x1, %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x6710
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x5488(%rip), %rsi      # 0xe48e
leaq 0x5d9f(%rip), %rcx      # 0xedac
callq 0x4550
movq %rax, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x11a0
cmpl $0x0, %eax
je 0x902f
movl $0x0, -0x4(%rbp)
jmp 0x9036
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x9097
movq 0x8f83(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xba09(%rip), %rdx      # 0x14a88
leaq 0x5d2b(%rip), %rsi      # 0xedb1
movb $0x0, %al
callq 0x1180
movl $0x1, %edi
callq 0x1260
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x90c1
movq $0x0, -0x8(%rbp)
jmp 0x917d
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x90d9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x90f9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x6710
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x5382(%rip), %rsi      # 0xe48e
leaq 0x5c99(%rip), %rcx      # 0xedac
callq 0x4550
movq %rax, %rdi
leaq 0x5c32(%rip), %rsi      # 0xed54
callq 0x1230
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x9175
movq -0x18(%rbp), %rax
cmpl $0x7fffffff, 0x4(%rax)  # imm = 0x7FFFFFFF
je 0x916b
movq 0x8eb3(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq 0xb939(%rip), %rdx      # 0x14a88
movq -0x20(%rbp), %rcx
leaq 0x5c8e(%rip), %rsi      # 0xede8
movb $0x0, %al
callq 0x1180
movl $0x1, %edi
callq 0x1260
movq $0x0, -0x8(%rbp)
jmp 0x917d
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/DB.c
// Function: Advance_Block_Arg
int Advance_Block_Arg(Block_Looper *e_parse)
{ _Block_Looper *parse = (_Block_Looper *) e_parse;

  if (Next_Block_Exists(e_parse))
    { parse->next += 1;
      return (1);
    }
  else
    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8f50
cmpl $0x0, %eax
je 0x91f8
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x91ff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jge 0x926c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x928c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x6710
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x5b82(%rip), %rsi      # 0xee19
callq 0x23e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x9387
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x10d0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9240
movq %rax, %rdi
callq 0x10d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
addq $0x1e, %rax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rdi
leaq 0x5acf(%rip), %rsi      # 0xee2f
callq 0x22c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x9385
movl $0x1, %edi
callq 0x1260
jmp 0x9387
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x93a7
movq $0x0, -0x8(%rbp)
jmp 0x946a
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x93cb
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jge 0x93fc
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x5a51(%rip), %rsi      # 0xee44
movb $0x0, %al
callq 0x1250
jmp 0x9451
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %r9d
addl $0x1, %r9d
movq -0x20(%rbp), %rax
movl 0x8(%rax), %r10d
addl -0x14(%rbp), %r10d
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
leaq 0x5a0f(%rip), %rsi      # 0xee4a
movl $0x40, %r8d
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x1250
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Histogram_Runs
static void Histogram_Runs(uint64 *run, uint8 *stream, int rlen, int runChar)
{ int k, h;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9fb5
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x21(%rbp)
jge 0x9f4d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x18(%rbp), %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x9f56
jmp 0x9f61
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9f2b
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jl 0x9f86
movq -0x8(%rbp), %rax
movq 0x7f8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x7f8(%rax)
jmp 0x9f9f
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9fb0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9f19
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Set_Endian
static void Set_Endian(int flip)
{ uint32 x = 3;
  uint8 *b = (uint8 *) (&x);

  Flip         = flip;
  LittleEndian = (b[0] == 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x3, -0x8(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0xcbf1(%rip)      # 0x17b80
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xcbdd(%rip)      # 0x17b84
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x33cc, -0x12(%rbp)    # imm = 0x33CC
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1270
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jge 0xafef
movw $0x100, -0x12(%rbp)     # imm = 0x100
jmp 0xaffa
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1270
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jge 0xb023
movw $0x100, -0x12(%rbp)     # imm = 0x100
jmp 0xb02e
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x12(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x1270
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x10d0
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1270
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movslq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1270
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xb110
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0xb0b1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xb110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xb110
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xb110
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xb110
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jl 0xb0ff
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xb110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x404, %rax            # imm = 0x404
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x15(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1270
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0xb1c3
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x15(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1270
movzbl -0x15(%rbp), %eax
cmpl $0x0, %eax
jle 0xb1b6
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1270
jmp 0xb1b8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb15f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Flip_Short
static void Flip_Short(void *w)
{ uint8 *v = (uint8 *) w;
  uint8  x;

  x    = v[0];
  v[0] = v[1];
  v[1] = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Flip_Long
static void Flip_Long(void *w)
{ uint8 *v = (uint8 *) w;
  uint8  x;

  x    = v[0];
  v[0] = v[3];
  v[3] = x;
  x    = v[1];
  v[1] = v[2];
  v[2] = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x3(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jl 0xb8e3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jl 0xb921
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Pack_Tag
static int Pack_Tag(char *tags, char *qvs, int rlen, int rchar)
{ int j, k;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc246
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x18(%rbp), %eax
je 0xc239
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0xc23b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc200
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Packed_Length
static int Packed_Length(char *qvs, int rlen, int rchar)
{ int k, clen;

  clen = 0;
  for (k = 0; k < rlen; k++)
    if (qvs[k] != rchar)
      clen += 1;
  return (clen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xd43b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x10(%rbp), %eax
je 0xd42e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd430
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd40c
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Unpack_Tag
static void Unpack_Tag(char *tags, int clen, char *qvs, int rlen, int rchar)
{ int j, k;

  j = clen-1;
  for (k = rlen-1; k >= 0; k--)
    { if (qvs[k] == rchar)
        tags[k] = 'n';
      else
        tags[k] = tags[j--];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xd4ba
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x20(%rbp), %eax
jne 0xd48d
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x6e, (%rax,%rcx)
jmp 0xd4ad
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xd4af
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd468
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/thegenemyers[P]DASCRUBBER/QV.c
// Function: Reheap
static void Reheap(int s, HTree **heap, int hsize)
{ int      c, l, r;
  HTree   *hs, *hr, *hl;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
cmpl -0x14(%rbp), %eax
jg 0xd599
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xd538
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xd566
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xd562
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xd564
jmp 0xd599
jmp 0xd594
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xd590
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xd592
jmp 0xd599
jmp 0xd594
jmp 0xd4e4
movl -0x18(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0xd5b1
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd60e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xd657
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xd5c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xd5c0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x29, -0xc(%rbp)
jge 0x443a
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x3e8, %ecx            # imm = 0x3E8
cmpl %ecx, %eax
jne 0x442d
movl $0x0, -0x4(%rbp)
jmp 0x4474
jmp 0x442f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x440e
movl $0x0, -0xc(%rbp)
cmpl $0x11, -0xc(%rbp)
jge 0x446d
movl -0x8(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x7d0, %ecx            # imm = 0x7D0
cmpl %ecx, %eax
jne 0x4460
movl $0x1, -0x4(%rbp)
jmp 0x4474
jmp 0x4462
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4441
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x3fe, %edx            # imm = 0x3FE
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
je 0x468f
movq -0x10(%rbp), %rax
cmpl $0x2, 0x140713c(%rax)
je 0x468f
leaq 0xddbba(%rip), %rdi     # 0xe2236
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x474f
movq -0x10(%rbp), %rax
cmpl $0x3, 0x140713c(%rax)
jne 0x46ec
movl -0x8(%rbp), %edi
movl $0x6, %esi
movl $0x3f9, %edx            # imm = 0x3F9
movl $0x3fa, %ecx            # imm = 0x3FA
movl $0x7d8, %r8d            # imm = 0x7D8
movl $0x7d9, %r9d            # imm = 0x7D9
movl $0x3e9, (%rsp)          # imm = 0x3E9
movl $0x7d1, 0x8(%rsp)       # imm = 0x7D1
movb $0x0, %al
callq 0x53e40
cmpl $0x0, %eax
jne 0x46ec
leaq 0xddb88(%rip), %rdi     # 0xe2264
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x474f
movl -0x8(%rbp), %edi
callq 0x4400
cmpl $0x0, %eax
jne 0x471a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x471a
leaq 0xddbc7(%rip), %rdi     # 0xe22d1
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x474f
movl -0x8(%rbp), %edi
callq 0x4400
cmpl $0x1, %eax
jne 0x4748
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x4748
leaq 0xddbcf(%rip), %rdi     # 0xe2307
movb $0x0, %al
callq 0x4030
movl $0x0, -0x4(%rbp)
jmp 0x474f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x29, -0x14(%rbp)
jge 0x536e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x3e8, %eax            # imm = 0x3E8
movslq %eax, %rcx
leaq 0xfee51(%rip), %rax     # 0x104190
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0x5361
movl -0x14(%rbp), %eax
addl $0x3e8, %eax            # imm = 0x3E8
movl %eax, -0x4(%rbp)
jmp 0x53c7
jmp 0x5363
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5323
movl $0x0, -0x14(%rbp)
cmpl $0x11, -0x14(%rbp)
jge 0x53c0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x7d0, %eax            # imm = 0x7D0
movslq %eax, %rcx
leaq 0xff46f(%rip), %rax     # 0x104800
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
callq 0x54990
cmpl $0x0, %eax
jne 0x53b3
movl -0x14(%rbp), %eax
addl $0x7d0, %eax            # imm = 0x7D0
movl %eax, -0x4(%rbp)
jmp 0x53c7
jmp 0x53b5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5375
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/olcaytaner[P]Isell/algorithm.c
// Function: free_supervised_algorithm_parameters
void free_supervised_algorithm_parameters(int algorithm, void* parameters)
{
 /*!Last Changed 02.04.2007 added HMM algorithm*/
 /*!Last Changed 14.08.2005*/
 switch (algorithm)
  {
   case RIPPER        :
   case IREP2         :
   case IREP          :
   case MULTIRIPPER   :
   case HYBRIDRIPPER  :
   case REXRIPPER     :
   case LDACLASS      :
   case KNN           :
   case KNNREG        :
   case GPROCESSREG   :
   case REGTREE       :
   case SVMREGTREE    :
   case SOFTREGTREE   :
   case SOFTTREE      :
   case LDT           :
   case NBTREE        :
   case RBF           :
   case RBFREG        :
   case MLPGENERIC    :
   case MLPGENERICREG :
   case DNC           :
   case DNCREG        :
   case MULTILDT      :
   case OMNILDT       :
   case QUANTIZEREG   :
   case REGRULE       :
   case SVM           :
   case SIMPLEXSVM    :
   case SVMREG        :
   case SIMPLEXSVMREG :
   case HMM           :
   case LOGISTIC      :
   case SVMTREE       :
   case RANDOMFOREST  :
   case KFOREST       :
   case C45           :
   case CN2           :
   case LERILS        :
   case CART          :safe_free(parameters);
                       break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
addl $0xfffffc17, %eax       # imm = 0xFFFFFC17
subl $0x2, %eax
jb 0x5aa9
jmp 0x5a25
movl -0x14(%rbp), %eax
addl $0xfffffc14, %eax       # imm = 0xFFFFFC14
subl $0x5, %eax
jb 0x5aa9
jmp 0x5a34
movl -0x14(%rbp), %eax
addl $0xfffffc0e, %eax       # imm = 0xFFFFFC0E
subl $0xa, %eax
jb 0x5aa9
jmp 0x5a43
movl -0x14(%rbp), %eax
addl $0xfffffc03, %eax       # imm = 0xFFFFFC03
subl $0x3, %eax
jb 0x5aa9
jmp 0x5a52
movl -0x14(%rbp), %eax
addl $0xfffffbfe, %eax       # imm = 0xFFFFFBFE
subl $0x2, %eax
jb 0x5aa9
jmp 0x5a61
movl -0x14(%rbp), %eax
addl $0xfffffbfa, %eax       # imm = 0xFFFFFBFA
subl $0x2, %eax
jb 0x5aa9
jmp 0x5a70
movl -0x14(%rbp), %eax
addl $0xfffffbf7, %eax       # imm = 0xFFFFFBF7
subl $0x2, %eax
jb 0x5aa9
jmp 0x5a7f
movl -0x14(%rbp), %eax
subl $0x40c, %eax            # imm = 0x40C
je 0x5aa9
jmp 0x5a8b
movl -0x14(%rbp), %eax
addl $0xfffff82f, %eax       # imm = 0xFFFFF82F
subl $0x3, %eax
jb 0x5aa9
jmp 0x5a9a
movl -0x14(%rbp), %eax
addl $0xfffff82a, %eax       # imm = 0xFFFFF82A
subl $0x8, %eax
ja 0x5ab2
jmp 0x5aa9
movq -0x10(%rbp), %rdi
callq 0x52e80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
leaq 0xd9ea8(%rip), %rsi     # 0xe295c
movl $0x2, %edx
callq 0x52d70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x8b4f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x52e80
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x52e80
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8b03
movq -0x8(%rbp), %rdi
callq 0x52e80
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x8eb0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jge 0x8e7d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x8e57
cmpl $0x0, -0x28(%rbp)
jne 0x8e6b
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x8e6d
cmpl $0x0, -0x28(%rbp)
jne 0x8e6d
jmp 0x8e7d
jmp 0x8e6f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8dea
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x10(%rcx), %eax
jne 0x8ea0
movl $0x1, -0x4(%rbp)
jmp 0x8eb7
jmp 0x8ea2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8dd3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xdf2e0(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f01
leaq 0xd9a7d(%rip), %rdi     # 0xe2972
movb $0x0, %al
callq 0x4030
jmp 0x8fe7
movl -0xc(%rbp), %edi
callq 0x51b20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8dc0
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8f7d
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x8f4a
jmp 0x8f40
movl -0x34(%rbp), %eax
subl $0x1, %eax
je 0x8f5e
jmp 0x8f70
movq -0x20(%rbp), %rdi
leaq 0xd9fe0(%rip), %rsi     # 0xe2f35
movb $0x0, %al
callq 0x4280
jmp 0x8f70
movq -0x20(%rbp), %rdi
leaq 0xd9a27(%rip), %rsi     # 0xe2990
movb $0x0, %al
callq 0x4280
jmp 0x8f72
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8f24
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
testl %eax, %eax
je 0x8f93
jmp 0x8f89
movl -0x38(%rbp), %eax
subl $0x1, %eax
je 0x8fa7
jmp 0x8fb9
movq -0x20(%rbp), %rdi
leaq 0xdcf5b(%rip), %rsi     # 0xe5ef9
movb $0x0, %al
callq 0x4280
jmp 0x8fb9
movq -0x20(%rbp), %rdi
leaq 0xdf31a(%rip), %rsi     # 0xe82cc
movb $0x0, %al
callq 0x4280
jmp 0x8fbb
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x52330
cmpl $0x0, %eax
jne 0x8f0d
movq -0x28(%rbp), %rdi
callq 0x52e80
movq -0x20(%rbp), %rdi
callq 0x4250
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xdf1ab(%rip), %rsi     # 0xe81be
callq 0x40c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9036
leaq 0xd9948(%rip), %rdi     # 0xe2972
movb $0x0, %al
callq 0x4030
jmp 0x9145
movl -0xc(%rbp), %edi
callq 0x51b20
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x8dc0
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x90b2
movq -0x30(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x907f
jmp 0x9075
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x9093
jmp 0x90a5
movq -0x28(%rbp), %rdi
leaq 0xd9eab(%rip), %rsi     # 0xe2f35
movb $0x0, %al
callq 0x4280
jmp 0x90a5
movq -0x28(%rbp), %rdi
leaq 0xd98f2(%rip), %rsi     # 0xe2990
movb $0x0, %al
callq 0x4280
jmp 0x90a7
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9059
xorps %xmm0, %xmm0
movsd 0xd8f5b(%rip), %xmm1    # 0xe2018
callq 0x545a0
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x90db
movl $0x1, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x40(%rbp)
testl %eax, %eax
je 0x90f1
jmp 0x90e7
movl -0x40(%rbp), %eax
subl $0x1, %eax
je 0x9105
jmp 0x9117
movq -0x28(%rbp), %rdi
leaq 0xdcdfd(%rip), %rsi     # 0xe5ef9
movb $0x0, %al
callq 0x4280
jmp 0x9117
movq -0x28(%rbp), %rdi
leaq 0xdf1bc(%rip), %rsi     # 0xe82cc
movb $0x0, %al
callq 0x4280
jmp 0x9119
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x1, %edx
callq 0x52330
cmpl $0x0, %eax
jne 0x9042
movq -0x30(%rbp), %rdi
callq 0x52e80
movq -0x28(%rbp), %rdi
callq 0x4250
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)