LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/hash.c
// Function: LHashSort
LHash* LHashSort(LHash* H,int lo,int hi){ //Taksinomisi tou Hash me ton algorithmo Quick sort vasi tou idf
  int j;
  if(lo<hi){
    j=LHashPartition(&H,lo,hi); //Orismos tou pivot
    H=LHashSort(H,lo,j);
    H=LHashSort(H,j+1,hi);
  }
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %rax
leaq -0x28(%rbp), %r14
movq %rax, -0x28(%rbp)
cmpl %ebx, %r15d
jge 0x49ad
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x49ba
movl %eax, %r12d
movq -0x28(%rbp), %rdi
movl %r15d, %esi
movl %eax, %edx
callq 0x4963
incl %r12d
movl %r12d, %r15d
jmp 0x497e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/hash.c
// Function: LHashPartition
int LHashPartition(LHash** H,int lo,int hi){ //Evresh tou pivot kai metathesh ton katalilwn thesewn sto Hash

  float pivot=(float)(*H)[lo].idf,ch;
  int i=lo,j=hi;
  while(i<j){
    do{
      i++;
      ch=(float)(*H)[i].idf;
    }while(ch>=pivot && (i<(j-1)));
    do{
       j--;
       ch=(float)(*H)[j].idf;
    }while(ch<pivot);
    if(i<j) (*H)=LHashSwap(*H,i,j);
  }
  (*H)=LHashSwap(*H,lo,j);
  return j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
movq (%rdi), %r14
movslq %esi, %rax
imulq $0x28, %rax, %rax
cvtsd2ss 0x8(%r14,%rax), %xmm1
movl %edx, %r12d
leaq 0x30(%r14), %r15
leaq -0x20(%r14), %rbx
movl %esi, -0x2c(%rbp)
movl %esi, %r13d
movss %xmm1, -0x30(%rbp)
cmpl %r12d, %r13d
jge 0x4a5c
leal -0x1(%r12), %eax
movslq %r13d, %r13
cltq
imulq $0x28, %r13, %rcx
addq %r15, %rcx
cvtsd2ss (%rcx), %xmm0
incq %r13
ucomiss %xmm1, %xmm0
jb 0x4a21
addq $0x28, %rcx
cmpq %rax, %r13
jl 0x4a0c
movslq %r12d, %r12
imulq $0x28, %r12, %rax
addq %rbx, %rax
cvtsd2ss (%rax), %xmm0
decq %r12
addq $-0x28, %rax
ucomiss %xmm0, %xmm1
ja 0x4a2b
cmpq %r12, %r13
jge 0x49f6
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x4a83
movss -0x30(%rbp), %xmm1
movq -0x38(%rbp), %rax
movq %r14, (%rax)
jmp 0x49f6
movq %r14, %rdi
movl -0x2c(%rbp), %esi
movl %r12d, %edx
callq 0x4a83
movq -0x38(%rbp), %rax
movq %r14, (%rax)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/hash.c
// Function: LHashSwap
LHash* LHashSwap(LHash* H,int i,int j){ //Metathesh twn thesewn i kai j sto Hash
  char* tw;
  double ti,tic;

  tw=H[i].word;
  ti=H[i].idf;
  tic=H[i].tfcount;

  H[i].word=H[j].word;
  H[i].idf=H[j].idf;
  H[i].tfcount=H[j].tfcount;

  H[j].word=tw;
  H[j].idf=ti;
  H[j].tfcount=tic;
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movslq %esi, %rcx
imulq $0x28, %rcx, %rcx
movq (%rdi,%rcx), %rsi
movups 0x8(%rdi,%rcx), %xmm0
movslq %edx, %rdx
imulq $0x28, %rdx, %rdx
movq (%rdi,%rdx), %rdi
movq %rdi, (%rax,%rcx)
movsd 0x8(%rax,%rdx), %xmm1
movsd %xmm1, 0x8(%rax,%rcx)
movsd 0x10(%rax,%rdx), %xmm1
movsd %xmm1, 0x10(%rax,%rcx)
movq %rsi, (%rax,%rdx)
movups %xmm0, 0x8(%rax,%rdx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/hash.c
// Function: LHashIncreaseTf
LHash* LHashIncreaseTf(LHash* H,char* word,double tf){
  int index,j=0;

  while(1){
    if(!j){
      index=hash1(word,H->size);
      j=1;
    }else{
      index++;
      if(index>=H->size) index-=H->size;
    }
    if(H[index].word==NULL){
      break;
    }else if(!strcmp(H[index].word,word)){
      H[index].tfcount=H[index].tfcount+tf;
      break;
    }
  }
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsd %xmm0, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, %cl
xorl %r12d, %r12d
testb $0x1, %cl
je 0x4aff
movl 0x18(%rbx), %esi
movq %r14, %rdi
callq 0x44af
movl %eax, %r15d
jmp 0x4b0f
incl %r15d
movl 0x18(%rbx), %eax
cmpl %eax, %r15d
cmovll %r12d, %eax
subl %eax, %r15d
movslq %r15d, %rax
imulq $0x28, %rax, %r13
movq (%rbx,%r13), %rdi
testq %rdi, %rdi
je 0x4b41
movq %r14, %rsi
callq 0x1140
xorl %ecx, %ecx
testl %eax, %eax
jne 0x4aea
addq %rbx, %r13
movsd -0x30(%rbp), %xmm0
addsd 0x10(%r13), %xmm0
movsd %xmm0, 0x10(%r13)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: JobCreate
Job* JobCreate(tfunc func,void* arg){//Dimiourgei ena neo JOb
    Job* job;

    if(func==NULL) return NULL;

    job=(Job*)malloc(sizeof(Job));  //Desmefsth tou xwrou
    job->func=func; //Anathesi ths routinas
    job->arg=arg; //Anathesi tou input
    job->Next=NULL;
    return job;
}

// Assembly:
testq %rdi, %rdi
je 0x4d13
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x11a0
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
andq $0x0, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: JSGetWork
Job* JSGetWork(JobSheduler* Sheduler){  //Epistrefi to pio palio Job
  Job* job;

  job=Sheduler->First;
  if(job==NULL) return NULL;

  if(job->Next==NULL){  //Ean einai to telefteo job ths ouras
    Sheduler->First=NULL;
    Sheduler->Last=NULL;
  }else{  //Ean iparxoun kai alla job h oura dixnei ws prwto to epomeno
    Sheduler->First=job->Next;
  }
  return job;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x4d41
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x4d3a
movq %rcx, (%rdi)
jmp 0x4d40
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: JSInit
JobSheduler* JSInit(int tnum){  //Dimiourgei ena Sheduler me tnum nimata
    JobSheduler* Sheduler;

    Sheduler=(JobSheduler*)malloc(sizeof(JobSheduler));
    Sheduler->threads=(pthread_t*)malloc(tnum*sizeof(pthread_t));
    Sheduler->threadsnum=tnum;
    Sheduler->num=tnum;
    Sheduler->threadswork=0;
    Sheduler->working=1;
    Sheduler->First=NULL;
    Sheduler->Last=NULL;

    pthread_mutex_init(&(Sheduler->lock), NULL);
    pthread_cond_init(&(Sheduler->notify), NULL);
    pthread_cond_init(&(Sheduler->thworking), NULL);

    for(int i=0 ; i<Sheduler->threadsnum ; i++){  //Kathe nima trexei thn sinartisi Worker
      pthread_create(&(Sheduler->threads[i]),NULL,Worker,(void*)Sheduler);
      pthread_detach(Sheduler->threads[i]);
    }
    return Sheduler;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %r14d
movl $0xb0, %edi
callq 0x11a0
movq %rax, %rbx
movslq %r14d, %r14
leaq (,%r14,8), %rdi
callq 0x11a0
movq %rax, 0x10(%rbx)
movl %r14d, 0xa0(%rbx)
movl %r14d, 0xa8(%rbx)
andl $0x0, 0xa4(%rbx)
movl $0x1, 0xac(%rbx)
leaq 0x18(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1280
leaq 0x40(%rbx), %rdi
xorl %esi, %esi
callq 0x1170
movq %rbx, %rdi
addq $0x70, %rdi
xorl %esi, %esi
callq 0x1170
leaq 0x45(%rip), %r14        # 0x4e09
xorl %r12d, %r12d
movslq 0xa0(%rbx), %rax
cmpq %rax, %r12
jge 0x4dfd
movq 0x10(%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x11d0
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
callq 0x11b0
incq %r12
addq $0x8, %r15
jmp 0x4dc7
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: Worker
void* Worker(void* arg){ //I sinarthsh pou trexei kathe nima kai mesw afths ektelite to kathe diathesimo Job
  JobSheduler* Sheduler=(void*)arg;
  Job* job;

  while (1) {
    pthread_mutex_lock(&(Sheduler->lock)); //Klidoma tou mutex
    while (Sheduler->First == NULL && Sheduler->working)  //Oso den iparxei kapio job perimene
      pthread_cond_wait(&(Sheduler->notify), &(Sheduler->lock));

    if(Sheduler->working==0) break; //An termatistike h litourgia tou Sheduler vgenei ap thn while

    job=JSGetWork(Sheduler); //Fere thn teleftea doulia ap thn oura
    Sheduler->threadswork++;
    pthread_mutex_unlock(&(Sheduler->lock));

    if(job != NULL) { //Ektelite to job kai meta katastrefete
      job->func(job->arg);
      JobDestroy(job);
    }

    pthread_mutex_lock(&(Sheduler->lock));
    Sheduler->threadswork--;
    if ((Sheduler->threadswork==0) && (Sheduler->First==NULL) && (Sheduler->working==1)) //Ean den iparxei kapio job den trexei kanena nima enhmerwse
          pthread_cond_signal(&(Sheduler->thworking));
    pthread_mutex_unlock(&(Sheduler->lock));
  }

  Sheduler->threadsnum--; //Miosi tou arithmu twn nhmatwn pou einai diathesima
  pthread_cond_signal(&(Sheduler->thworking));
  pthread_mutex_unlock(&(Sheduler->lock));
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x40(%rdi), %r12
leaq 0x70(%rdi), %r15
movq %rbx, %rdi
callq 0x1290
cmpq $0x0, (%r14)
movl 0xac(%r14), %eax
jne 0x4e4c
testl %eax, %eax
je 0x4eb5
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1090
jmp 0x4e2e
testl %eax, %eax
je 0x4eb5
movq %r14, %rdi
callq 0x4d20
movq %rax, %r13
incl 0xa4(%r14)
movq %rbx, %rdi
callq 0x1190
testq %r13, %r13
je 0x4e7f
movq 0x8(%r13), %rdi
callq *(%r13)
movq %r13, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1290
decl 0xa4(%r14)
jne 0x4ea8
cmpq $0x0, (%r14)
jne 0x4ea8
cmpl $0x1, 0xac(%r14)
jne 0x4ea8
movq %r15, %rdi
callq 0x1120
movq %rbx, %rdi
callq 0x1190
jmp 0x4e26
decl 0xa0(%r14)
movq %r15, %rdi
callq 0x1120
movq %rbx, %rdi
callq 0x1190
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: JSAddWork
void JSAddWork(JobSheduler* Sheduler,Job* job){ //Eisagi ena neo Job sthn oura

  pthread_mutex_lock(&(Sheduler->lock));  //Klidoma tou mutex
   if(Sheduler->First == NULL){ //Ean den iparxei kapio job
       Sheduler->First = job;
       Sheduler->Last = job;
   }else{ //Ean iparxei idi kapio job sthn oura
      Sheduler->Last->Next = job;
      Sheduler->Last=job;
   }

   pthread_cond_broadcast(&(Sheduler->notify)); //Idopeiei ta nimata oti iparxei kapio neo job sthn oura
   pthread_mutex_unlock(&(Sheduler->lock)); //Klidoma tou mutex

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x1290
cmpq $0x0, (%r14)
je 0x4f09
movq 0x8(%r14), %rax
movq %r15, 0x10(%rax)
jmp 0x4f0c
movq %r15, (%r14)
movq %r15, 0x8(%r14)
addq $0x40, %r14
movq %r14, %rdi
callq 0x1070
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: JSWaitalltasks
void JSWaitalltasks(JobSheduler* Sheduler){ //Perimenei na teliosoun ola ta nimata

  pthread_mutex_lock(&(Sheduler->lock));
  while(1){
    if ( ((Sheduler->working==0) && (Sheduler->threadsnum!=0)) || ( ((Sheduler->threadswork!=0) && (Sheduler->working!=0) ) || (Sheduler->First!=NULL) ) ){ //Oso iparxoun nimata pou litourgoun
      pthread_cond_wait(&(Sheduler->thworking), &(Sheduler->lock)); //Perimene mexri na teliosi to nima
    }else{
      break;
    }
  }
  pthread_mutex_unlock(&(Sheduler->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x1290
leaq 0x70(%r14), %r15
cmpl $0x0, 0xac(%r14)
je 0x4f61
cmpl $0x0, 0xa4(%r14)
jne 0x4f71
jmp 0x4f6b
cmpl $0x0, 0xa0(%r14)
jne 0x4f71
cmpq $0x0, (%r14)
je 0x4f7e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1090
jmp 0x4f4b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O2/DVaronos[P]AnLogProject1/JobSheduler.c
// Function: JSDestroy
void JSDestroy(JobSheduler* Sheduler){  //Katastrofh tou Sheduler

    Job* job;
    Job* tmpjob;

    pthread_mutex_lock(&(Sheduler->lock));
    job=Sheduler->First;
    while(job != NULL) {  //Katastrofh twn Job pou perimenoun sthn oura
        tmpjob=job->Next;
        JobDestroy(job);
        job=tmpjob;
    }
    Sheduler->working=0;  //Thetoume thn metavlhth workink 0 ara den dexonte alles doulies ta nimata
    pthread_cond_broadcast(&(Sheduler->notify));
    pthread_mutex_unlock(&(Sheduler->lock));

    JSWaitalltasks(Sheduler); //Perimenoume ta nimata pou litourgoun na teleiwsoun


    pthread_mutex_destroy(&(Sheduler->lock));
    pthread_cond_destroy(&(Sheduler->notify));
    pthread_cond_destroy(&(Sheduler->thworking));

    //Apodesmefsh tou Sheduler
    free(Sheduler->threads);
    free(Sheduler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x1290
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4fbf
movq 0x10(%rdi), %r15
callq 0x1030
movq %r15, %rdi
jmp 0x4fac
andl $0x0, 0xac(%rbx)
leaq 0x40(%rbx), %r15
movq %r15, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1190
movq %rbx, %rdi
callq 0x4f2e
movq %r14, %rdi
callq 0x10e0
movq %r15, %rdi
callq 0x11e0
leaq 0x70(%rbx), %rdi
callq 0x11e0
movq 0x10(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_leb128
static inline int _obp_leb128(uint8_t *buf, size_t size, uint64_t *value, ptrdiff_t *consumed, OBPError *err)
{
    *value       = 0;
    *consumed    = 0;

    for (uint64_t i = 0; i < 8; i++) {
        uint8_t b;

        if (((size_t) (*consumed) + 1) > size) {
            snprintf(err->error, err->size, "Buffer too short to read leb128 value.");
            return -1;
        }

        b       = buf[*consumed];
        *value |= ((uint64_t)(b & 0x7F)) << (i * 7);
        (*consumed)++;

        if ((b & 0x80) != 0x80)
            break;
    }

    return 0;
}

// Assembly:
pushq %rbx
movq %rcx, %r9
andq $0x0, (%rdx)
andq $0x0, (%rcx)
xorl %eax, %eax
xorl %ecx, %ecx
xorl %r11d, %r11d
leaq 0x7(%rcx), %r10
cmpq $0x3f, %r10
je 0x134c
leaq 0x1(%r11), %rbx
cmpq %rsi, %rbx
ja 0x1334
movzbl (%rdi,%r11), %ebx
movl %ebx, %r11d
andl $0x7f, %r11d
shlq %cl, %r11
orq %r11, (%rdx)
movq (%r9), %r11
incq %r11
movq %r11, (%r9)
movq %r10, %rcx
testb %bl, %bl
js 0x12fd
jmp 0x134c
movq (%r8), %rdi
movq 0x8(%r8), %rsi
leaq 0x7121(%rip), %rdx      # 0x8463
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_br_unchecked
static inline uint64_t _obp_br_unchecked(_OBPBitReader *br, uint8_t n)
{
    assert(n <= 63);

    while (n > br->bits_in_buf) {
        br->bit_buffer <<= 8;
        br->bit_buffer  |= (uint64_t) br->buf[br->buf_pos];
        br->bits_in_buf += 8;
        br->buf_pos++;

        if (br->bits_in_buf > 56) {
            if (n <= br->bits_in_buf)
                break;

            if (n <= 64)
                return (_obp_br_unchecked(br, 32) << 32) | (_obp_br_unchecked(br, n - 32));
        }
    }

    br->bits_in_buf -= n;
    return (br->bit_buffer >> br->bits_in_buf) & ((((uint64_t)1) << n) - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x20
popq %rbp
cmpb $0x3f, %bl
ja 0x2581
movb 0x20(%r14), %cl
movq 0x18(%r14), %rdx
cmpb %bl, %cl
jae 0x255c
movq %rdx, %rax
shlq $0x8, %rax
movq %rax, 0x18(%r14)
movq (%r14), %rdx
movq 0x10(%r14), %rsi
movzbl (%rdx,%rsi), %edx
orq %rax, %rdx
movq %rdx, 0x18(%r14)
addb $0x8, %cl
movb %cl, 0x20(%r14)
incq %rsi
movq %rsi, 0x10(%r14)
cmpb $0x39, %cl
jb 0x250e
cmpb %bl, %cl
jae 0x255c
movq %r14, %rdi
movl %ebp, %esi
callq 0x24ef
shlq $0x20, %rax
addb $-0x20, %bl
orq %rax, %r15
jmp 0x2501
subb %bl, %cl
movb %cl, 0x20(%r14)
shrq %cl, %rdx
pushq $-0x1
popq %rax
movl %ebx, %ecx
shlq %cl, %rax
notq %rax
andq %rdx, %rax
orq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5f02(%rip), %rdi      # 0x848a
leaq 0x5b3c(%rip), %rsi      # 0x80cb
leaq 0x5efc(%rip), %rcx      # 0x8492
pushq $0x2e
popq %rdx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_parse_tile_list
int obp_parse_tile_list(uint8_t *buf, size_t buf_size, OBPTileList *tile_list, OBPError *err)
{
    size_t pos = 0;

    if (buf_size < 4) {
        snprintf(err->error, err->size, "Tile list OBU must be at least 4 bytes.");
        return -1;
    }

    tile_list->output_frame_width_in_tiles_minus_1  = buf[0];
    tile_list->output_frame_height_in_tiles_minus_1 = buf[1];
    tile_list->tile_count_minus_1                   = (((uint16_t) buf[2]) << 8) | buf[3];
    pos += 4;

    for (uint16_t i = 0; i < tile_list->tile_count_minus_1; i++) {
        if (pos + 5 > buf_size) {
            snprintf(err->error, err->size, "Tile list OBU malformed: Not enough bytes for next tile_list_entry().");
            return -1;
        }

        tile_list->tile_list_entry[i].anchor_frame_idx       = buf[pos];
        tile_list->tile_list_entry[i].anchor_tile_row        = buf[pos + 1];
        tile_list->tile_list_entry[i].anchor_tile_col        = buf[pos + 2];
        tile_list->tile_list_entry[i].tile_data_size_minus_1 = (((uint16_t) buf[pos + 3]) << 8) | buf[pos + 4];
        pos += 5;

        size_t N = 8 * (((size_t) tile_list->tile_list_entry[i].tile_data_size_minus_1) + 1);

        if (pos + N > buf_size) {
            snprintf(err->error, err->size, "Tile list OBU malformed: Not enough bytes for next tile_list_entry()'s data.");
            return -1;
        }

        tile_list->tile_list_entry[i].coded_tile_data      = buf + pos;
        tile_list->tile_list_entry[i].coded_tile_data_size = N;
        pos += N;
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x3, %rsi
ja 0x25c6
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
leaq 0x5bd2(%rip), %rdx      # 0x8189
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rbx
jmp 0x267b
movb (%rdi), %al
movb %al, (%rdx)
movb 0x1(%rdi), %al
movb %al, 0x1(%rdx)
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %r14d
movw %r14w, 0x2(%rdx)
addq $0x8, %rdx
pushq $0x4
popq %r9
xorl %ebx, %ebx
leaq 0x5bbf(%rip), %rax      # 0x81b1
leaq 0x5bfe(%rip), %r8       # 0x81f7
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x267b
leaq 0x5(%r9), %r10
cmpq %rsi, %r10
ja 0x2663
movb (%rdi,%r9), %r11b
movb %r11b, (%rdx)
movb 0x1(%rdi,%r9), %r11b
movb %r11b, 0x1(%rdx)
movb 0x2(%rdi,%r9), %r11b
movb %r11b, 0x2(%rdx)
movzwl 0x3(%rdi,%r9), %r9d
rolw $0x8, %r9w
movw %r9w, 0x4(%rdx)
movzwl %r9w, %r11d
leaq (%r10,%r11,8), %r9
addq $0x8, %r9
cmpq %rsi, %r9
ja 0x2660
leaq 0x8(,%r11,8), %r11
addq %rdi, %r10
movq %r10, 0x8(%rdx)
movq %r11, 0x10(%rdx)
incq %r15
addq $0x18, %rdx
jmp 0x25fc
movq %r8, %rax
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
xorl %ebx, %ebx
movq %rax, %rdx
xorl %eax, %eax
callq 0x1030
cmpq %r14, %r15
sbbl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_parse_frame
int obp_parse_frame(uint8_t *buf, size_t buf_size, OBPSequenceHeader *seq, OBPState *state,
                    int temporal_id, int spatial_id, OBPFrameHeader *fh, OBPTileGroup *tile_group,
                    int *SeenFrameHeader, OBPError *err)
{
    size_t startBitPos = 0, endBitPos, headerBytes;
    int ret = obp_parse_frame_header(buf, buf_size, seq, state, temporal_id, spatial_id, fh, SeenFrameHeader, err);
    if (ret < 0) {
        return -1;
    }
    endBitPos   = state->frame_header_end_pos;
    headerBytes = (endBitPos - startBitPos) / 8;
    return obp_parse_tile_group(buf + headerBytes, buf_size - headerBytes, fh, tile_group, SeenFrameHeader, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq 0x58(%rsp), %rbx
movq 0x50(%rsp), %r14
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rbp
subq $0x8, %rsp
pushq %rbx
pushq %r14
pushq %rbp
callq 0x1070
addq $0x20, %rsp
testl %eax, %eax
js 0x33fa
movq 0x460(%r12), %rax
shrq $0x3, %rax
addq %rax, %r13
subq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq (%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_get_relative_dist
static inline int32_t _obp_get_relative_dist(int32_t a, int32_t b, OBPSequenceHeader *seq)
{
    int32_t diff, m;

    if (!seq->enable_order_hint)
        return 0;

    diff = a - b;
    m    = 1 << (seq->OrderHintBits - 1);
    diff = (diff & (m - 1)) - (diff & m);

    return diff;
}

// Assembly:
cmpl $0x0, 0x4e8(%rdx)
je 0x743a
subl %esi, %edi
movb 0x505(%rdx), %cl
decb %cl
pushq $0x1
popq %rdx
shll %cl, %edx
leal -0x1(%rdx), %eax
andl %edi, %eax
andl %edi, %edx
subl %edx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_ns
static inline int _obp_ns(_OBPBitReader *br, uint32_t n, uint32_t *out, OBPError *err)
{
    uint32_t w = _obp_floor_log2(n) + 1;
    uint32_t m = (((uint32_t)1) << w) - n;
    uint32_t v;
    uint32_t extra_bit;

    assert(w - 1 <= 32);
    _obp_br(v, br, ((uint8_t)(w - 1)));
    if (v < m) {
        *out = v;
        return 0;
    }
    _obp_br(extra_bit, br, 1);
    *out = (v << 1) - m + extra_bit;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
pushq $-0x1
popq %rax
movl %esi, %ecx
testl %ecx, %ecx
je 0x745d
shrl %ecx
incl %eax
jmp 0x7453
leal 0x1(%rax), %ecx
pushq $0x1
popq %rbp
shll %cl, %ebp
cmpl $0x21, %eax
jae 0x74fb
movzbl 0x20(%r15), %ecx
movl %eax, %edx
subl %ecx, %edx
addl $0x7, %edx
sarl $0x3, %edx
movslq %edx, %rcx
movq 0x8(%r15), %rdx
subq 0x10(%r15), %rdx
cmpq %rcx, %rdx
jae 0x74a7
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0xcd2(%rip), %rdx       # 0x816d
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
jmp 0x74f2
subl %esi, %ebp
movzbl %al, %esi
movq %r15, %rdi
callq 0x24ef
movq %rax, %r12
cmpl %r12d, %ebp
ja 0x74ed
movzbl 0x20(%r15), %eax
pushq $0x8
popq %rcx
subl %eax, %ecx
sarl $0x3, %ecx
movslq %ecx, %rax
movq 0x8(%r15), %rcx
subq 0x10(%r15), %rcx
cmpq %rax, %rcx
jb 0x748d
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x24ef
addl %r12d, %r12d
subl %ebp, %r12d
addl %eax, %r12d
movl %r12d, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1020(%rip), %rdi      # 0x8522
leaq 0xbc2(%rip), %rsi       # 0x80cb
leaq 0x101e(%rip), %rcx      # 0x852e
movl $0xc2, %edx
callq 0x1040
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_read_delta_q
static inline int _obp_read_delta_q(_OBPBitReader *br, int32_t *out, OBPError *err)
{
    int delta_coded;
    _obp_br(delta_coded, br, 1);
    if (delta_coded) {
        int32_t val;
        int ret = _obp_su(br, 7, &val, err);
        if (ret < 0)
            return ret;
        *out = val;
    } else {
        *out = 0;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movzbl 0x20(%rdi), %eax
pushq $0x8
popq %rcx
subl %eax, %ecx
sarl $0x3, %ecx
movslq %ecx, %rax
movq 0x8(%rdi), %rcx
subq 0x10(%rdi), %rcx
cmpq %rax, %rcx
jae 0x755c
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0xc1d(%rip), %rdx       # 0x816d
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
jmp 0x7592
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rsi
callq 0x24ef
testl %eax, %eax
je 0x758d
pushq $0x7
popq %rsi
leaq 0xc(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x759c
testl %eax, %eax
js 0x7557
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
jmp 0x7590
andl $0x0, (%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obp_su
static inline int _obp_su(_OBPBitReader *br, uint32_t n, int32_t *out, OBPError *err)
{
    int32_t value;
    uint32_t signMask;

    _obp_br(value, br, n);
    signMask = ((uint32_t)1) << (n - 1);
    if (value & signMask) {
        value = value - 2 * signMask;
    }
    *out = value;
    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movzbl 0x20(%rdi), %eax
movl %esi, %edx
subl %eax, %edx
addl $0x7, %edx
shrl $0x3, %edx
movq 0x8(%rdi), %rax
subq 0x10(%rdi), %rax
cmpq %rdx, %rax
jae 0x75d7
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
leaq 0xba2(%rip), %rdx       # 0x816d
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
jmp 0x75fe
movzbl %sil, %ebp
movl %ebp, %esi
callq 0x24ef
decb %bpl
movzbl %bpl, %ecx
pushq $-0x2
popq %rsi
shll %cl, %esi
movq %rax, %rdx
xorl %eax, %eax
btq %rcx, %rdx
cmovael %eax, %esi
addl %edx, %esi
movl %esi, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dwbuiten[P]obuparse/obuparse.c
// Function: obps_inverse_recenter
static inline int32_t _obps_inverse_recenter(int32_t r, uint32_t v)
{
    if (((uint64_t)v) > ((uint64_t)(2 * r))) {
        return (int32_t) v;
    } else if (v & 1) {
        return r - ((v + 1) >> 1);
    } else {
        return r + (v >> 1);
    }
}

// Assembly:
movl %esi, %eax
movl %esi, %ecx
leal (%rdi,%rdi), %edx
movslq %edx, %rdx
cmpq %rdx, %rcx
ja 0x7863
testb $0x1, %al
jne 0x7864
shrl %eax
addl %edi, %eax
retq
incl %eax
shrl %eax
subl %eax, %edi
movl %edi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_sanityOfFlow
int pr_sanityOfFlow(struct Graph* g, struct Vertex* s, struct Vertex* t, FILE* out) {
	int sOuttIn = s->visited + t->visited;

	int excessViolated = 0;
	for (int vi=0; vi<g->n; ++vi) {
		struct Vertex* v = g->vertices[vi];
		if ((v != s) && (v != t)) {
			if (v->visited != 0) {
				++excessViolated;
			}
		}
	}

	if (out) {
		fprintf(out, "excess s: %i, excess t:%i, violations in between: %i\n", s->visited, t->visited, excessViolated);
	}

	return !sOuttIn && !excessViolated;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl 0x1c(%rsi), %ebx
movl 0x1c(%rdx), %ebp
movl (%rdi), %eax
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
xorl %r14d, %r14d
cmpq %r8, %rax
je 0x13bb
movq 0x10(%rdi), %r9
movq (%r9,%r8,8), %r9
cmpq %rsi, %r9
sete %r10b
cmpq %rdx, %r9
sete %r11b
orb %r10b, %r11b
jne 0x13b6
cmpl $0x1, 0x1c(%r9)
sbbl $-0x1, %r14d
incq %r8
jmp 0x138d
testq %rcx, %rcx
je 0x13d8
leaq 0x1bc3d(%rip), %rsi     # 0x1d004
movq %rcx, %rdi
movl %ebx, %edx
movl %ebp, %ecx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x1150
negl %ebp
xorl %ebp, %ebx
xorl %eax, %eax
orl %r14d, %ebx
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_sanityOfFinalActiveArray
int pr_sanityOfFinalActiveArray(struct ShallowGraph** activeVertices, int nLists, FILE* out) {
	int forgottenVertices = 0;
	for (int i=0; i<nLists; ++i) {
		if (peekFromVertexQueue(activeVertices[i])) {
			forgottenVertices += activeVertices[i]->m;
			if (out) {
				fprintf(out, "Level %i: Vertex %i\n", i, peekFromVertexQueue(activeVertices[i])->number);
			}
		}
	}
	if (out) {
		fprintf(out, "total of forgotten vertices: %i\n", forgottenVertices);
	}
	return forgottenVertices;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %r14d
movq %rdi, %r15
leaq 0x1bc2e(%rip), %r12     # 0x1d03a
xorl %r13d, %r13d
xorl %ebp, %ebp
cmpq %r13, %r14
je 0x144d
movq (%r15,%r13,8), %rdi
callq 0x1bac9
testq %rax, %rax
je 0x1448
movq (%r15,%r13,8), %rdi
addl 0x10(%rdi), %ebp
testq %rbx, %rbx
je 0x1448
callq 0x1bac9
movl 0x18(%rax), %ecx
movq %rbx, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x1150
incq %r13
jmp 0x1411
testq %rbx, %rbx
je 0x1465
leaq 0x1bbf6(%rip), %rsi     # 0x1d04f
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augment
char augment(struct Vertex* s, struct Vertex* t) {
	struct VertexList* e;

	if (s == t) {
		return 1;
	}
	s->visited = 1;
	for (e=s->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			char found = augment(e->endPoint, t);
			if (found) {
				setFlag(e, 1);
				s->visited = 0;
				return 1;
			}
		}
	}
	s->visited = 0;
	return 0;
}

// Assembly:
cmpq %rsi, %rdi
je 0x175d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0x1c(%rdi)
movq %rdi, %r15
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x1751
cmpl $0x0, 0x24(%r15)
jne 0x1718
movq 0x18(%r15), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x1718
movq %r14, %rsi
callq 0x16fe
testb %al, %al
je 0x1718
movl $0x1, 0x24(%r15)
movq (%r15), %rax
andl $0x0, 0x24(%rax)
movb $0x1, %al
jmp 0x1753
xorl %eax, %eax
andl $0x0, 0x1c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augmentWithCapacity
char augmentWithCapacity(struct Vertex* s, struct Vertex* t) {
	if (s == t) {
		return 1;
	}

	s->visited = 1;
	for (struct VertexList* e=s->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag < e->used) && (e->endPoint->visited == 0)) {
			char found = augmentWithCapacity(e->endPoint, t);
			if (found) {
				addFlow(e, 1);
				s->visited = 0;
				return 1;
			}
		}
	}
	s->visited = 0;
	return 0;
}

// Assembly:
cmpq %rsi, %rdi
je 0x17bd
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, 0x1c(%rdi)
movq %rdi, %r15
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x17b1
movl 0x24(%r15), %eax
cmpl 0x20(%r15), %eax
jge 0x177a
movq 0x18(%r15), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x177a
movq %r14, %rsi
callq 0x1760
testb %al, %al
je 0x177a
incl 0x24(%r15)
movq (%r15), %rax
decl 0x24(%rax)
movb $0x1, %al
jmp 0x17b3
xorl %eax, %eax
andl $0x0, 0x1c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: getMatchedVertex
struct Vertex* getMatchedVertex(struct Vertex* a) {
	struct VertexList* e;
	for (e=a->neighborhood; e!=NULL; e=e->next) {
		if (e->flag == 1) {
			return e->endPoint;
		}
	}
	return NULL;
}

// Assembly:
xorl %eax, %eax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x17d5
cmpl $0x1, 0x24(%rdi)
jne 0x17c2
movq 0x18(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: addResidualEdges
void addResidualEdges(struct Vertex* v, struct Vertex* w, struct ListPool* lp) {
	struct VertexList* f1;
	struct VertexList* f2;

	f1 = getVertexList(lp);
	f1->startPoint = v;
	f1->endPoint = w;
	f2 = inverseEdge(f1, lp);

	f1->flag = 0;
	f2->flag = 1;
	f1->label = (char*)f2;
	f2->label = (char*)f1;

	addEdge(v, f1);
	addEdge(w, f2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x11307
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5a44
andl $0x0, 0x24(%r12)
movq %rax, %rbx
movl $0x1, 0x24(%rax)
movq %rax, (%r12)
movq %r12, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5b2c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5b2c
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: addResidualEdgesWithCapacity
void addResidualEdgesWithCapacity(struct Vertex* v, struct Vertex* w, int capacity, struct ListPool* lp) {
	struct VertexList* f1;
	struct VertexList* f2;

	f1 = getVertexList(lp);
	f1->startPoint = v;
	f1->endPoint = w;
	f2 = inverseEdge(f1, lp);

	f1->used = capacity;
	f2->used = capacity;
	f1->flag = 0;
	f2->flag = capacity;
	f1->label = (char*)f2;
	f2->label = (char*)f1;

	addEdge(v, f1);
	addEdge(w, f2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdi
callq 0x11307
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5a44
movq %rax, %rbx
movl %ebp, 0x20(%r12)
movl %ebp, 0x20(%rax)
andl $0x0, 0x24(%r12)
movl %ebp, 0x24(%rax)
movq %rax, (%r12)
movq %r12, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5b2c
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5b2c
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: _cloneStrangeBipartite
struct Graph* __cloneStrangeBipartite(struct Graph* g, struct GraphPool* gp) {
	int v; 
	struct VertexList* e;
	struct Graph* h = createGraph(g->n, gp);
	h->number = g->number;
	h->m = g->m;

	for (v=0; v<g->number; ++v) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {		
			addResidualEdges(h->vertices[v], h->vertices[e->endPoint->number], gp->listPool);
		}
	}
	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x630e
movq %rax, %r15
movl 0x8(%r14), %eax
movl %eax, 0x8(%r15)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%r15)
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x1921
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x1918
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
movq 0x18(%r13), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rbx), %rdx
callq 0x17e4
jmp 0x18f0
incq %r12
movl 0x8(%r14), %eax
jmp 0x18e1
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: initBipartite
void initBipartite(struct Graph* B) {
	int i;
	struct VertexList* e;
	for (i=0; i<B->number; ++i) {
		for (e=B->vertices[i]->neighborhood; e!=NULL; e=e->next) {
			setFlag(e, 0);
		}
	}
}

// Assembly:
movslq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x195f
movq 0x10(%rdi), %rdx
movq (%rdx,%rcx,8), %rdx
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x195a
andl $0x0, 0x24(%rdx)
movq (%rdx), %rsi
movl $0x1, 0x24(%rsi)
jmp 0x1941
incq %rcx
jmp 0x1934
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: removeSandT
void removeSandT(struct Graph* B, struct Vertex* s, struct Vertex* t, struct GraphPool* gp) {	
	int w;

	for (w=0; w<B->number; ++w) {
		removeEdge(B->vertices[w], s, gp->listPool);
	}

	for (w=B->number; w<B->n; ++w) {
		removeEdge(B->vertices[w], t, gp->listPool);
	}

	dumpVertexListRecursively(gp->listPool, s->neighborhood);
	dumpVertexListRecursively(gp->listPool, t->neighborhood);

	dumpVertex(gp->vertexPool, s);
	dumpVertex(gp->vertexPool, t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
movslq 0x8(%r12), %r13
cmpq %r13, %rbp
jge 0x19b5
movq 0x10(%r12), %rax
movq (%rax,%rbp,8), %rdi
movq 0x18(%r14), %rdx
movq %r15, %rsi
callq 0x5b39
incq %rbp
jmp 0x1979
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rdi
movq 0x18(%r14), %rdx
movq %rbx, %rsi
callq 0x5b39
incq %r13
movslq (%r12), %rax
cmpq %rax, %r13
jl 0x199d
movq 0x18(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x1138e
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x1138e
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x11512
movq 0x10(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11512
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingFastAndDirty
int bipartiteMatchingFastAndDirty(struct Graph* g, struct GraphPool* gp) {
	int v;
	int matchingSize = 0;

	struct Vertex* s = getVertex(gp->vertexPool);
	struct Vertex* t = getVertex(gp->vertexPool);
	s->number = -1;
	t->number = -2;

	/* Add s, t and edges from s to A and from B to t.
	Also, set residual capacities for these edges correctly */
	for (v=0; v<g->number; ++v) {
		addResidualEdges(s, g->vertices[v], gp->listPool);
	}

	for (v=g->number; v<g->n; ++v) {
		addResidualEdges(g->vertices[v], t, gp->listPool);
	}

	while (augment(s, t)) {
		++matchingSize;
	}

	removeSandT(g, s, t, gp);

	return matchingSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
callq 0x114a5
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x114a5
orl $-0x1, 0x18(%r15)
movq %rax, %r12
movl $0xfffffffe, 0x18(%rax) # imm = 0xFFFFFFFE
xorl %ebp, %ebp
movslq 0x8(%r14), %r13
cmpq %r13, %rbp
jge 0x1a6e
movq 0x10(%r14), %rax
movq (%rax,%rbp,8), %rsi
movq 0x18(%rbx), %rdx
movq %r15, %rdi
callq 0x17e4
incq %rbp
jmp 0x1a35
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
movq 0x18(%rbx), %rdx
movq %r12, %rsi
callq 0x17e4
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x1a57
pushq $-0x1
popq %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x16fe
incl %ebp
testb %al, %al
jne 0x1a79
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1960
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingEvenMoreDirty
int bipartiteMatchingEvenMoreDirty(struct Graph* g) {
	int matchingSize = 0;
	int activity = g->activity;
	while (augment_B(g)) {
		++matchingSize;
	}
	g->activity = activity;
	return matchingSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0xc(%rdi), %r14d
xorl %ebp, %ebp
movl %r14d, %r15d
movslq %r15d, %r12
leal 0x1(%r12), %r15d
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jge 0x1b0a
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rsi
cmpl $0x0, 0x28(%rsi)
jne 0x1aeb
movq %rbx, %rdi
callq 0x1b67
testb %al, %al
jne 0x1af3
incq %r12
incl %r15d
jmp 0x1ac8
movl %r15d, 0xc(%rbx)
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rax
movl $0x1, 0x28(%rax)
incl %ebp
jmp 0x1ac0
movl %r14d, 0xc(%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingTerminateEarly
char bipartiteMatchingTerminateEarly(struct Graph* B) {

	for (int v=0; v<B->number; ++v) {
		if (B->vertices[v]->d == 0) {
			char found = augment_B_rec(B, B->vertices[v]);
			if (found) {
				B->vertices[v]->d = 1;
			} else {
				return 0;
			}
		}
	}
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x8(%rbx), %r15
cmpq %r15, %r14
jge 0x1b5b
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rsi
cmpl $0x0, 0x28(%rsi)
jne 0x1b56
movq %rbx, %rdi
callq 0x1b67
testb %al, %al
je 0x1b5b
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movl $0x1, 0x28(%rax)
incq %r14
jmp 0x1b24
cmpq %r15, %r14
setge %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augment_B_rec
static char augment_B_rec(struct Graph* B, struct Vertex* v) {
	struct VertexList* e;

	if ((v->number >= B->number) && (v->d == 0)) {
		v->d = 1;
		return 1;
	}
	v->visited = 1;
	for (e=v->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			char found = augment_B_rec(B, e->endPoint);
			if (found) {
				setFlag(e, 1);
				v->visited = 0;
				return 1;
			}
		}
	}
	v->visited = 0;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %eax
cmpl 0x8(%rdi), %eax
jl 0x1b80
cmpl $0x0, 0x28(%rbx)
je 0x1bcd
movl $0x1, 0x1c(%rbx)
movq %rbx, %r15
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x1bc5
cmpl $0x0, 0x24(%r15)
jne 0x1b8a
movq 0x18(%r15), %rsi
cmpl $0x0, 0x1c(%rsi)
jne 0x1b8a
movq %r14, %rdi
callq 0x1b67
testb %al, %al
je 0x1b8a
movl $0x1, 0x24(%r15)
movq (%r15), %rax
andl $0x0, 0x24(%rax)
andl $0x0, 0x1c(%rbx)
jmp 0x1bd4
andl $0x0, 0x1c(%rbx)
xorl %eax, %eax
jmp 0x1bd6
movl $0x1, 0x28(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: getMatching
struct ShallowGraph* getMatching(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* matching = getShallowGraph(sgp);
	struct VertexList* e;
	int v;
	
	for (v=0; v<g->number; ++v) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->flag == 1) {
				struct VertexList* f = shallowCopyEdge(e, sgp->listPool);
				f->label = NULL;
				appendEdge(matching, f);
			}
		}
	}
	return matching;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x117e9
movq %rax, %r15
xorl %r13d, %r13d
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0x1c3e
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %r12
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x1c39
cmpl $0x1, 0x24(%r12)
jne 0x1c0a
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x5a28
andq $0x0, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
jmp 0x1c0a
incq %r13
jmp 0x1bf9
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatching
struct ShallowGraph* bipartiteMatching(struct Graph* h, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* matching;
	struct Graph* g = __cloneStrangeBipartite(h, gp);

	bipartiteMatchingFastAndDirty(g, gp);
	matching = getMatching(g, sgp);
	rebaseShallowGraphs(matching, h); 

	/* garbage collection */
	dumpGraph(gp, g);

	return matching;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x18b5
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x19fe
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1bdc
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x64e8
movq %r14, %rdi
movq %r12, %rsi
callq 0x1166e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bitSet.c
// Function: copyBitset
uint8_t* copyBitset(uint8_t* bitset, size_t n) {
	uint8_t* copy = createBitset(n);
	size_t nBytes = (n % 8 == 0) ? (n / 8) : (n / 8 + 1);
	memcpy(copy, bitset, nBytes);
	return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1ca4
movl %ebx, %ecx
andl $0x7, %ecx
shrq $0x3, %rbx
cmpq $0x1, %rcx
sbbq $-0x1, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1160
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bitSet.c
// Function: printBitset
void printBitset(uint8_t* bitset, size_t n, FILE* out) {
	fprintf(out, "[");
	for (size_t i=0; i<n; ++i) {
		fprintf(out, "%i", getBit(bitset, i));
	}
	fprintf(out, "]\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x5b
popq %rdi
movq %rdx, %rsi
callq 0x1100
leaq 0x1c7d8(%rip), %r12     # 0x1e54a
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x1da6
movq %r13, %rax
shrq $0x3, %rax
movzbl (%r15,%rax), %eax
movl %r13d, %ecx
andl $0x7, %ecx
xorl %edx, %edx
btl %ecx, %eax
setb %dl
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1150
incq %r13
jmp 0x1d75
leaq 0x1b2c3(%rip), %rdi     # 0x1d070
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1210
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bloomFilter.c
// Function: initPruning
void initPruning(const int nGraphs) {
	nPruning = nGraphs;
	if ((pruning = malloc(nGraphs * sizeof(int)))) {
		int i;
		for (i=0; i<nGraphs; ++i) {
			pruning[i] = 0;
		}
	}
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %edi, 0x28357(%rip)     # 0x2a168
movslq %edi, %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, 0x2834c(%rip)     # 0x2a170
testq %rax, %rax
je 0x1e3e
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x1e3e
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x1e30
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/bloomFilter.c
// Function: initialAddToPruningSet
void initialAddToPruningSet(const int elementID, const int index) {
	if (index >= nPruning) {
		int i;
		pruning = realloc(pruning, 2 * nPruning * sizeof(int));
		for (i=nPruning; i<2*nPruning; ++i) {
			pruning[i] = 0;
		}
		nPruning *= 2;
	}
	addToPruningSet(elementID, index);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq 0x282de(%rip), %r14     # 0x2a168
movq 0x282df(%rip), %rax     # 0x2a170
cmpl %esi, %r14d
jg 0x1ec7
leaq (%r14,%r14), %r15
leaq (,%r14,8), %rsi
movq %rax, %rdi
callq 0x11b0
movq %rax, 0x282bf(%rip)     # 0x2a170
cmpq %r15, %r14
jge 0x1ec0
andl $0x0, (%rax,%r14,4)
incq %r14
jmp 0x1eb1
movl %r15d, 0x282a1(%rip)    # 0x2a168
pushq $0x1
popq %rdx
movl %ebp, %ecx
shll %cl, %edx
movslq %ebx, %rcx
orl %edx, (%rax,%rcx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/cachedGraph.c
// Function: initCachedGraph
struct CachedGraph* initCachedGraph(struct GraphPool* gp, int size) {
	struct CachedGraph* cache;
	if ((cache = malloc(sizeof(struct CachedGraph)))) {
		cache->gp = gp;
		cache->inUse = 0;
		cache->g = createGraph(size, gp);
		// __setVertexNumber(cache->g, size, gp);
		cache->maxCap = size;
		cache->next = NULL;
	}
	return cache;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x1180
movq %rax, %r14
testq %rax, %rax
je 0x1f55
movq %r15, 0x20(%r14)
movb $0x0, (%r14)
movl %ebx, %edi
movq %r15, %rsi
callq 0x630e
movq %rax, 0x8(%r14)
movl %ebx, 0x10(%r14)
andq $0x0, 0x18(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/cachedGraph.c
// Function: getCachedGraph
struct Graph* getCachedGraph(int size, struct CachedGraph* cache) {
	 if (!cache->inUse) {
	 	cache->inUse = 1;
		if (cache->maxCap < size) {
			// do the 'increase size by factor of two' thing to avoid many reallocs
			int newCap = max(size, 2 * cache->maxCap);
			
			// dump old graph
			cache->g->n = cache->maxCap;
			dumpGraph(cache->gp, cache->g);
			
			// create larger new graph
			cache->g = createGraph(newCap, cache->gp);
			cache->maxCap = newCap;
		} 
		cache->g->n = size;	
		return cache->g;
	} else {
		fprintf(stderr, "Graph is in use\n");
		return NULL;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x0, (%rsi)
jne 0x1fb4
movq %rsi, %r14
movl %edi, %ebx
movb $0x1, (%rsi)
movl 0x10(%rsi), %esi
cmpl %edi, %esi
jge 0x1fa9
addl %esi, %esi
movl %ebx, %edi
callq 0x7524
movl %eax, %ebp
movl 0x10(%r14), %eax
movq 0x8(%r14), %rsi
movl %eax, (%rsi)
movq 0x20(%r14), %rdi
callq 0x1166e
movq 0x20(%r14), %rsi
movl %ebp, %edi
callq 0x630e
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
jmp 0x1fad
movq 0x8(%r14), %rax
movl %ebx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2803d(%rip), %rax     # 0x29ff8
movq (%rax), %rcx
leaq 0x1b0ae(%rip), %rdi     # 0x1d073
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x1210
xorl %eax, %eax
jmp 0x1faf