LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: HashDiff
void HashDiff(Hash* H,FILE* csvfile){//Metaferi ta dedomena pou den teriazoun se ena csv arxio
	NList *L;
  TList* Transfered=CreateTList();
	for(int i=0 ; i<H->size ; i++){
		L=(NList*)H[i].Head;
		DiffNList(L,Transfered,csvfile);
	}
  FreeTList(Transfered);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x4750
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6170
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4b20
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6132
movq -0x20(%rbp), %rdi
callq 0x45f0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: CheckIfOpposite
CList** CheckIfOpposite (Hash* H, char* first){
	NList* L;
	int i=0,j=0,in;
	char name[40];
	while(first[i]!='/'){//Vrisko to simio pou teliwnei to onoma ths istoselidas tou proiontos
	  i++;
	}
	i+=2;//pigeno to i sthn thesh pou arxizei o arithmos tou proiontos
	while(i<strlen(first)){
	   name[j]=first[i];
	   j++;
	   i++;
	}
	name[j]='\0';
	in=atoi(name);//apothievo ton arithmo tou proiontos ston int in
	int index=hash(in,H->size);
	L=(NList*)H[index].Head;//pernw thn lista pou vriskete sto index bucket tou HashTable
	while(L->Next!=NULL){	//Vrisko ton komvo ston opio einai apothikevmeno to product
		L=L->Next;
		if(!strcmp(L->camera,first)){
        return &(L->clique);
		}
	}
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x61ba
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x619e
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x6207
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x60(%rbp,%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x61c3
movslq -0x28(%rbp), %rax
movb $0x0, -0x60(%rbp,%rax)
leaq -0x60(%rbp), %rdi
callq 0x1230
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x5970
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movslq -0x64(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6280
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x627e
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x6288
jmp 0x6244
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: HashPrint
void HashPrint(Hash* H){//Ektiponei to HashTable
	NList *L;
	for(int i=0 ; i<H->size ; i++){
		L=(NList*)H[i].Head;
		PrintNList(L);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x62e9
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a40
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62b3
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: HashVectorts
Hash* HashVectorts(Hash* H,LHash* Lek){ //Dimiourgei ena vector gia kathe camera
	NList *L;
  double tf,value;

	for(int i=0 ; i<H->size ; i++){  //Gia kathe bucket tou Hash
		L=(NList*)H[i].Head;
		while(L->Next!=NULL){ //Gia kathe komvo ths NList(ara gia kathe kameras)
      L=L->Next;
      L->vector=CreateHVector(200);
      for(int j=0 ; j<Lek->size ; j++){ //Gia kathe leksh tou Lek
        tf=GiveTfIdf(L->Spear,Lek[j].word);  //Pernw to tf ths lekshs an iparxei sthn camera alios to tf ginete 0
        if(tf){ //ean iparxi h leksh sthn camera
          value=tf*Lek[j].tfcount;  //h timh ginete tf*idf
          L->vector=InsertHVector(L->vector,j,value); //isagogi sto vector
        }
      }
      L->vec_size = Lek->size;
      FreeWHash(L->Spear);  //Apodemsevw to WHash ths cameras afou pleon den to xriazome
      L->Spear=NULL;
    }

	}
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x6434
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6424
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0xc8, %edi
callq 0x5490
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x63f8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x52f0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x63aa
jp 0x63aa
jmp 0x63e8
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x30(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
mulsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x30(%rbp), %esi
movsd -0x28(%rbp), %xmm0
callq 0x5520
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x63ea
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6364
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4c80
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x632d
jmp 0x6426
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6307
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: HashFind
WHash* HashFind(Hash* H,char* word){
  NList *L;
	int i=0,j=0,in;
	char name[20];
  while(word[i]!='/'){//Vrisko to simio pou teliwnei to onoma ths istoselidas tou proiontos
    i++;
  }
	i+=2;//pigeno to i sthn thesh pou arxizei o arithmos tou proiontos
	while(i<strlen(word)){
		name[j]=word[i];
		j++;
		i++;
	}
	name[j]='\0';
	in=atoi(name);//apothievo ton arithmo tou proiontos ston int in
	int index=hash(in,H->size);
  L=(NList*)H[index].Head;//pernw thn lista pou vriskete sto index bucket tou HashTable
  while(L->Next!=NULL){
    L=L->Next;
    if(!strcmp(L->camera,word)) return L->Spear;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x647a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x645e
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x64c7
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x40(%rbp,%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6483
movslq -0x28(%rbp), %rax
movb $0x0, -0x40(%rbp,%rax)
leaq -0x40(%rbp), %rdi
callq 0x1230
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x5970
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movslq -0x44(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x6540
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x653e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6548
jmp 0x6504
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: LHashCreate
LHash* LHashCreate(int size){ //Dimiourgei ena neo LHashTable megetous size
  int i;
	LHash *H;
	H=(LHash* )malloc(size *  sizeof(LHash) );
	H->size=size;
  H->count=0;
  for(i=0 ; i< size ; i++){ //gia kathe bucket tou LHashTable arxikopiei ta dedomena tou
    H[i].word=NULL;
    H[i].idf=0.0;
    H[i].tfcount=0;
    H[i].wordperj=0;
	}
	return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rax
imulq $0x28, %rax, %rdi
callq 0x1190
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x6655
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movslq -0x8(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x20(%rax)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x65e8
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: LHashInsert
LHash* LHashInsert(LHash* H,char* camera){ /*Eisagei enan neo product sto LHashTable*/
  int index,exist=0,j=0;

  while(1){ //Evresi tou bucket pou tha paei to neo product
    if(!j){ //Sthn proth epanalipsh ipologizoume mono thn sinartish hash
      index=hash1(camera,H->size);
      j=1;
    }else{
      index++;
      if(index>=H->size) index-=H->size;
    }
    if(H[index].word==NULL){  //Ean einai adio to bucket tha isagoume se afto thn camera
      break;
    }else if(!strcmp(H[index].word,camera)){  //Ean iparxi idi tha vgoume ap thn epanalipsh
      exist=1;
      break;
    }
  }
  if(!exist){ //Ean h camera den iparxei idi
    H->count++;
    H[index].word=strdup(camera);
    H[index].wordperj=1;
    float n=(1.0*H->count)/H->size;
    if(n>=0.8){ //Ean h plirotita ftasei to 80% kanei rehash
      H=Lrehash(H);
    }
  }else{
    H[index].wordperj=H[index].wordperj+1;
  }
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x66a0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x6560
movl %eax, -0x14(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x66c6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x66c4
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x66c6
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x66dd
jmp 0x670d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x6706
movl $0x1, -0x18(%rbp)
jmp 0x670d
jmp 0x6708
jmp 0x667e
cmpl $0x0, -0x18(%rbp)
jne 0x67a9
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rdi
callq 0x1250
movq %rax, %rcx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
cvtsi2sdl 0x1c(%rax), %xmm1
movsd 0x1ac7(%rip), %xmm0     # 0x8230
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x18(%rax), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1afc(%rip), %xmm1     # 0x8290
ucomisd %xmm1, %xmm0
jb 0x67a7
movq -0x8(%rbp), %rdi
callq 0x67e0
movq %rax, -0x8(%rbp)
jmp 0x67d0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: FreeLHash
void FreeLHash(LHash* H){   //apodesmefsth tou Hash
  for(int i=0 ; i<H->size ; i++){
    free(H[i].word);
  }
  free(H);
}

// 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 0x18(%rcx), %eax
jge 0x6a51
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a23
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: LHashPrint
void LHashPrint(LHash* H){  //Ektiponei to Leksilogio
  int i,c=0;
  for(i=0 ; i<H->size ; i++){
    if(H[i].word!=NULL){
      c++;
      printf("%d.%s-%f-%f\n",c,H[i].word,H[i].idf,H[i].tfcount);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x6aff
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x6aef
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm1
leaq 0x1818(%rip), %rdi      # 0x8300
movb $0x2, %al
callq 0x10b0
jmp 0x6af1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6a7a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: LHashTfIdf
void LHashTfIdf(LHash* Lek,double count){ //Dimiourgei ena vector gia kathe camera
  double t;
  int wc=0;
	for(int i=0 ; i<Lek->size ; i++){  //Gia kathe bucket tou leksilogiou
    if(Lek[i].word!=NULL){  //An iparxei leksh
        wc++;
        Lek[i].idf=log10(count/(Lek[i].wordperj));//Ipologizo to idf
        t=Lek[i].idf;
        Lek[i].idf=(Lek[i].idf*Lek[i].tfcount)/count;//Ipologizo to meso tf-idf
        Lek[i].tfcount=t; //krataw to idf sto tfcoun
      }
      if(wc==Lek->count) break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x6c28
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x6c0a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cvtsi2sdl 0x20(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x1130
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
mulsd 0x10(%rax), %xmm0
divsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jne 0x6c18
jmp 0x6c28
jmp 0x6c1a
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6b2f
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: LHashFind
int LHashFind(LHash* H,char* camera){ //Epistrefei 1 an iparxei  leksh sto hash allios 0
  int index,exist=0,j=0;

  while(1){
    if(!j){
      index=hash1(camera,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,camera)){
      exist=1;
      break;
    }
  }
  return exist;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x6c70
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x6560
movl %eax, -0x14(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x6c96
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x6c94
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x6c96
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x6cad
jmp 0x6cdd
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x6cd6
movl $0x1, -0x18(%rbp)
jmp 0x6cdd
jmp 0x6cd8
jmp 0x6c4e
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DVaronos[P]AnLogProject1/hash.c
// Function: NMostLHash
LHash* NMostLHash(LHash* H,int n){ //Epistrefei ena Hash pou periexei mono tis n simantikoteres lekseis tou hash
  if(n>H->size) n=H->size;
  H=LHashSort(H,0,H->size);
  LHash*  Temp;
  int i;
  Temp=(LHash* )malloc( n *  sizeof(LHash) ); //Dimiourgo ena neo HasTable me n size
  Temp->size=n;
  Temp->count=n;
  for(i=0 ; i<n ; i++){
    Temp[i].word=NULL;
    Temp[i].idf=0.0;
    Temp[i].tfcount=0.0;
  }
  for(i=0 ; i< n ; i++){  //Pernaw ta dedomena tou paliou sto neo HasTable
        Temp[i].word=H[i].word;
        Temp[i].idf=H[i].idf;
        Temp[i].tfcount=H[i].tfcount;
        H[i].word=NULL;
  }
  FreeLHash(H);
  H=Temp;
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jle 0x6d15
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
xorl %esi, %esi
callq 0x6e80
movq %rax, -0x8(%rbp)
movslq -0xc(%rbp), %rax
imulq $0x28, %rax, %rdi
callq 0x1190
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6dae
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6d57
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6e59
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6db5
movq -0x8(%rbp), %rdi
callq 0x6a10
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x6ed5
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq -0x8(%rbp), %rdi
callq 0x6ee0
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x6e80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x6e80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6fe0
jmp 0x6f2c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
xorl %eax, %eax
ucomiss -0x14(%rbp), %xmm0
movb %al, -0x21(%rbp)
jb 0x6f76
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6f2c
jmp 0x6f7f
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
ja 0x6f7f
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6fdb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x7010
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6f1e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x7010
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x716e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x6560
movl %eax, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x7194
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jl 0x7192
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7194
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x71ab
jmp 0x7201
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x71fa
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd 0x10(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
jmp 0x7201
jmp 0x71fc
jmp 0x714c
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7501
movq $0x0, -0x8(%rbp)
jmp 0x753a
movl $0x18, %edi
callq 0x1190
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x75a4
movq $0x0, -0x8(%rbp)
jmp 0x75df
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x75c8
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x75d7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0xb0, %edi
callq 0x1190
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x1190
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa0(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xa4(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xac(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1260
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1160
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1160
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xa0(%rcx), %eax
jge 0x76fe
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x37(%rip), %rdx        # 0x7710
callq 0x11c0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x76a8
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1270
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
jne 0x7751
movq -0x10(%rbp), %rax
cmpl $0x0, 0xac(%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x775a
jmp 0x7771
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1070
jmp 0x7731
movq -0x10(%rbp), %rax
cmpl $0x0, 0xac(%rax)
jne 0x7783
jmp 0x7834
movq -0x10(%rbp), %rdi
callq 0x7580
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xa4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa4(%rax)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1180
cmpq $0x0, -0x18(%rbp)
je 0x77d1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0x7550
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1270
movq -0x10(%rbp), %rax
movl 0xa4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xa4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x7822
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7822
movq -0x10(%rbp), %rax
cmpl $0x1, 0xac(%rax)
jne 0x7822
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x1110
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1180
jmp 0x7724
movq -0x10(%rbp), %rax
movl 0xa0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xa0(%rax)
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x1110
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x1180
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1270
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x78b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x78cc
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x1060
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1180
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1270
movq -0x8(%rbp), %rax
cmpl $0x0, 0xac(%rax)
jne 0x7923
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa0(%rax)
jne 0x7947
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
je 0x793d
movq -0x8(%rbp), %rax
cmpl $0x0, 0xac(%rax)
jne 0x7947
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x795e
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x1070
jmp 0x7960
jmp 0x7962
jmp 0x7909
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1180
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1270
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x79ca
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7550
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x79a4
movq -0x8(%rbp), %rax
movl $0x0, 0xac(%rax)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x1060
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1180
movq -0x8(%rbp), %rdi
callq 0x78f0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x10c0
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x11d0
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
callq 0x11d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_is_valid_obu
static inline int _obp_is_valid_obu(OBPOBUType type)
{
    return type == OBP_OBU_SEQUENCE_HEADER ||
           type == OBP_OBU_TEMPORAL_DELIMITER ||
           type == OBP_OBU_FRAME_HEADER ||
           type == OBP_OBU_TILE_GROUP ||
           type == OBP_OBU_METADATA ||
           type == OBP_OBU_FRAME ||
           type == OBP_OBU_REDUNDANT_FRAME_HEADER ||
           type == OBP_OBU_TILE_LIST ||
           type == OBP_OBU_PADDING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, %al
cmpl $0x1, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x2, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x3, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x4, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x5, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x6, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x7, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
movb $0x1, %al
cmpl $0x8, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x1499
cmpl $0xf, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x38(%rbp)
cmpq $0x8, -0x38(%rbp)
jae 0x158e
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jbe 0x152c
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xdf33(%rip), %rdx      # 0xf44f
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1595
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movzbl -0x39(%rbp), %eax
andl $0x7f, %eax
cltq
imulq $0x7, -0x38(%rbp), %rcx
shlq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movzbl -0x39(%rbp), %eax
andl $0x80, %eax
cmpl $0x80, %eax
je 0x157b
jmp 0x158e
jmp 0x157d
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x14ea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x3f, %eax
jg 0x3c3d
jmp 0x3c5c
leaq 0xb832(%rip), %rdi      # 0xf476
leaq 0xb46c(%rip), %rsi      # 0xf0b7
movl $0x2e, %edx
leaq 0xb827(%rip), %rcx      # 0xf47e
callq 0x1040
jmp 0x3c5e
movzbl -0x11(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jle 0x3d29
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x8, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
orq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
addl $0x8, %ecx
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x38, %eax
jle 0x3d24
movzbl -0x11(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jg 0x3ce0
jmp 0x3d29
movzbl -0x11(%rbp), %eax
cmpl $0x40, %eax
jg 0x3d22
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq 0x3c20
shlq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x11(%rbp), %eax
subl $0x20, %eax
movzbl %al, %esi
callq 0x3c20
movq %rax, %rcx
movq -0x20(%rbp), %rax
orq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x3d6b
jmp 0x3d24
jmp 0x3c5e
movzbl -0x11(%rbp), %edx
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
subl %edx, %ecx
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movzbl -0x11(%rbp), %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwbuiten[P]obuparse/obuparse.c
// Function: obp_uvlc
static inline int _obp_uvlc(_OBPBitReader *br, uint32_t *value, OBPError *err)
{
    uint32_t leading_zeroes = 0;
    while (leading_zeroes < 32) {
        int b;
        _obp_br(b, br, 1);
        if (b != 0)
            break;
        leading_zeroes++;
    }
    if (leading_zeroes == 32) {
        snprintf(err->error, err->size, "Invalid VLC.");
        return -1;
    }
    uint32_t val;
    _obp_br(val, br, leading_zeroes);
    *value = val + ((1 << leading_zeroes) - 1);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x20, -0x24(%rbp)
jae 0x3e2e
jmp 0x3da7
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %ecx
movl $0x1, %eax
subl %ecx, %eax
addl $0x8, %eax
subl $0x1, %eax
sarl $0x3, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x3e07
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xb365(%rip), %rdx      # 0xf159
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ef1
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3c20
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x3e20
jmp 0x3e2e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3d9b
cmpl $0x20, -0x24(%rbp)
jne 0x3e5d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xb669(%rip), %rdx      # 0xf4b3
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ef1
jmp 0x3e5f
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
subl %ecx, %eax
addl $0x8, %eax
subl $0x1, %eax
shrl $0x3, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
subq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x3eba
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xb2af(%rip), %rdx      # 0xf159
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3ef1
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movzbl %al, %esi
callq 0x3c20
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x24(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl -0x44(%rbp), %ecx
subl $0x1, %eax
addl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)