LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/logistic.c
// Function: Newpred
double Newpred(double* w,double b,HVector* F,HVector* S,int dif){//Vriskei to predict xwris na ginei to concat

	int fr,se,c;
	double wx,sum=b;

	fr=F->sum;
	se=S->sum;
	if(fr>se){//Eelgxo pio ap ta dio vectors tha mpei proto
		c=0;
		for(int i=0 ; i<F->size ; i++){	//Isago tis leksis tou protou vector
			if(F[i].key!=-1){
				c++;
				wx=w[F[i].key]*(F[i].value);
				sum+=wx;
			}
			if(c==F->count) break;
		}
		c=0;
		for(int i=0 ; i<S->size ; i++){	//Isago tis leksis tou defterou vectour me afksimeno to key kata dif
			if(S[i].key!=-1){
				c++;
				wx=w[(S[i].key)+dif]*(S[i].value);
				sum+=wx;
			}
			if(c==S->count) break;
		}
	}else{
		c=0;
		for(int i=0 ; i<S->size ; i++){
			if(S[i].key!=-1){
				c++;
				wx=w[(S[i].key)]*(S[i].value);
				sum+=wx;
			}
			if(c==S->count) break;
		}
		c=0;
		for(int i=0 ; i<F->size ; i++){
			if(F[i].key!=-1){
				c++;
				wx=w[(F[i].key)+dif]*(F[i].value);
				sum+=wx;
			}
			if(c==F->count) break;
		}
	}
	sum=1 / (1 + exp(-(sum)));	//ipologizoume to p(f(x))
	return sum;
}

// Assembly:
cvttsd2si 0x10(%rsi), %eax
cvttsd2si 0x10(%rdx), %r8d
cmpl %r8d, %eax
jle 0x2a5f
movslq 0x1c(%rsi), %rax
testq %rax, %rax
jle 0x2a03
movl 0x18(%rsi), %r8d
shlq $0x5, %rax
addq $-0x20, %rax
xorl %r9d, %r9d
xorl %r10d, %r10d
movslq (%rsi,%r9), %r11
cmpq $-0x1, %r11
je 0x29f2
incl %r10d
movsd (%rdi,%r11,8), %xmm1
mulsd 0x8(%rsi,%r9), %xmm1
addsd %xmm1, %xmm0
cmpl %r8d, %r10d
je 0x2a03
leaq 0x20(%r9), %r11
cmpq %r9, %rax
movq %r11, %r9
jne 0x29d4
movslq 0x1c(%rdx), %rax
testq %rax, %rax
jle 0x2af8
movl 0x18(%rdx), %esi
shlq $0x5, %rax
addq $-0x20, %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
movl (%rdx,%r8), %r10d
cmpl $-0x1, %r10d
je 0x2a45
incl %r9d
addl %ecx, %r10d
movslq %r10d, %r10
movsd (%rdi,%r10,8), %xmm1
mulsd 0x8(%rdx,%r8), %xmm1
addsd %xmm1, %xmm0
cmpl %esi, %r9d
je 0x2af8
leaq 0x20(%r8), %r10
cmpq %r8, %rax
movq %r10, %r8
jne 0x2a21
jmp 0x2af8
movslq 0x1c(%rdx), %rax
testq %rax, %rax
jle 0x2aa9
movl 0x18(%rdx), %r8d
shlq $0x5, %rax
addq $-0x20, %rax
xorl %r9d, %r9d
xorl %r10d, %r10d
movslq (%rdx,%r9), %r11
cmpq $-0x1, %r11
je 0x2a98
incl %r10d
movsd (%rdi,%r11,8), %xmm1
mulsd 0x8(%rdx,%r9), %xmm1
addsd %xmm1, %xmm0
cmpl %r8d, %r10d
je 0x2aa9
leaq 0x20(%r9), %r11
cmpq %r9, %rax
movq %r11, %r9
jne 0x2a7a
movslq 0x1c(%rsi), %rax
testq %rax, %rax
jle 0x2af8
movl 0x18(%rsi), %edx
shlq $0x5, %rax
addq $-0x20, %rax
xorl %r8d, %r8d
xorl %r9d, %r9d
movl (%rsi,%r8), %r10d
cmpl $-0x1, %r10d
je 0x2ae7
incl %r9d
addl %ecx, %r10d
movslq %r10d, %r10
movsd (%rdi,%r10,8), %xmm1
mulsd 0x8(%rsi,%r8), %xmm1
addsd %xmm1, %xmm0
cmpl %edx, %r9d
je 0x2af8
leaq 0x20(%r8), %r10
cmpq %r8, %rax
movq %r10, %r8
jne 0x2ac3
pushq %rbp
movq %rsp, %rbp
xorpd 0x373c(%rip), %xmm0     # 0x6240
callq 0x12a0
movsd 0x3707(%rip), %xmm1     # 0x6218
addsd %xmm1, %xmm0
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/logistic.c
// Function: MakeArrays
void MakeArrays(Hash* H,int* s,NList*** nodes){ //Dimiourgo ena pinaka me NList nodes twn kamerwn pou den einai mesa se kapia klika
	NList* N;
	int sum=0;
	for(int i=0 ; i<H->size ; i++){
		N=(NList*)H[i].Head;
    while(N->Next!=NULL){
      N=N->Next;
			if(N->clique==NULL){
      	sum++;
			}
    }
	}

	NList** nl=malloc(sum*sizeof(NList*));
	sum=0;
	for(int i=0 ; i<H->size ; i++){
		N=(NList*)H[i].Head;
    while(N->Next!=NULL){
      N=N->Next;
			if(N->clique==NULL){
				nl[sum]=N;
      	sum++;
			}
    }
	}
	*s=sum;
	*nodes=nl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rdi), %r12
xorl %r13d, %r13d
testq %r12, %r12
jle 0x2d9e
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, %rdx
shlq $0x4, %rdx
movq 0x8(%r15,%rdx), %rdx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0x2d8d
cmpq $0x1, 0x10(%rdx)
movq 0x20(%rdx), %rsi
adcl $0x0, %ecx
movq %rsi, %rdx
testq %rsi, %rsi
jne 0x2d79
incq %rax
cmpq %r12, %rax
jne 0x2d64
movslq %ecx, %rdi
shlq $0x3, %rdi
jmp 0x2da0
xorl %edi, %edi
callq 0x11a0
testl %r12d, %r12d
jle 0x2ddf
xorl %ecx, %ecx
xorl %r13d, %r13d
movq %rcx, %rdx
shlq $0x4, %rdx
movq 0x8(%r15,%rdx), %rdx
movq 0x20(%rdx), %rdx
testq %rdx, %rdx
je 0x2dd7
cmpq $0x0, 0x10(%rdx)
jne 0x2dbb
movslq %r13d, %r13
movq %rdx, (%rax,%r13,8)
incl %r13d
jmp 0x2dbb
incq %rcx
cmpq %r12, %rcx
jne 0x2daf
movl %r13d, (%r14)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/logistic.c
// Function: RepetitiveTaining
Model* RepetitiveTaining(Input* input,Hash* H,JobSheduler* Sheduler){
	int size = H->Head->Next->vec_size,ep=1;
	Model* model;
	double threshold=0.1,stepvalue=0.1;
	model=ModelIinit(size);

	model->b=0;
	while (threshold < 0.35){
		model = Training(model,input,H,Sheduler);
		printf("Just finished the training for %d time\n",ep);
		TestAndAdd(H,model,Sheduler,&input,threshold);
		threshold+=stepvalue;
		ep++;
	}
	return model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %rax
movq %rdi, (%rax)
movq 0x8(%rsi), %rax
movq 0x20(%rax), %rax
movslq 0x28(%rax), %r12
movl $0x18, %edi
callq 0x11a0
movq %rax, %r13
leal (%r12,%r12), %eax
movl %eax, 0x10(%r13)
shlq $0x4, %r12
movq %r12, %rdi
callq 0x11a0
movq %rax, (%r13)
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x10f0
movq $0x0, 0x8(%r13)
movsd 0x31f4(%rip), %xmm0     # 0x6238
movl $0x1, %r12d
movsd %xmm0, -0x30(%rbp)
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq 0x2325
leaq 0x3203(%rip), %rdi      # 0x6267
movl %r12d, %esi
xorl %eax, %eax
callq 0x10d0
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
leaq -0x38(%rbp), %rcx
movsd -0x30(%rbp), %xmm0
callq 0x2b1f
movsd -0x30(%rbp), %xmm0
addsd 0x31a6(%rip), %xmm0     # 0x6238
movsd %xmm0, -0x30(%rbp)
incl %r12d
cmpl $0x4, %r12d
jne 0x304f
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: CreateCList
CList* CreateCList(){ //Dimiourgei mia nea CList
	CList *L;
	L=(CList *)malloc(sizeof(CList));
	L->Next=NULL;
  	L->name=NULL;
	L->Diffrend=NULL;
	L->camera_count = 0;
	return L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x28, %edi
callq 0x11a0
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: InsertCList
void InsertCList(CList* L,char* product,NList* Head){//Eisagei ena neo product sthn arxh ths CList
  CList *N;
  N=(CList*)malloc(sizeof(CList));
  N->name=malloc(sizeof(char)*(strlen(product)+1));
  strcpy(N->name,product);
	N->Head=Head;
  N->Next=L->Next;
  L->Next=N;
  L->camera_count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x28, %edi
callq 0x11a0
movq %rax, %r12
movq %r14, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11a0
movq %rax, (%r12)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1060
movq %rbx, 0x8(%r12)
movq 0x18(%r15), %rax
movq %rax, 0x18(%r12)
movq %r12, 0x18(%r15)
incl 0x20(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: TransferCList
void TransferCList(CList* L,FILE* csvfile){	//Eisagi  ta proionta sto csv file
  CList* N;
  char* current;
  while(L->Next!=NULL){
    L=L->Next;
    N=L;
    current=malloc(sizeof(char)*(strlen(L->name)+1));//apothikefsi tou trexon komvou
    strcpy(current,L->name);
    while(N->Next!=NULL){	//Eisagogi tou trexon komvou mazi me ton kathe ena ap tous epomenous
      N=N->Next;
      fprintf(csvfile,"%s, %s\n",current,N->name);

    }
    free(current);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdi), %r13
testq %r13, %r13
je 0x31b2
movq %rsi, %rbx
leaq 0x3166(%rip), %r14      # 0x62c0
movq (%r13), %r12
movq %r12, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11a0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x1060
movq 0x18(%r13), %r12
testq %r12, %r12
je 0x31a1
movq (%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1160
movq 0x18(%r12), %r12
jmp 0x3181
movq %r15, %rdi
callq 0x1030
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x315a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: DiffCList
void DiffCList(CList* L,TList* Transfered,FILE* csvfile){	//Eisagi  ta proionta sto csv file
  TList* N;
	TList* C;
	CList* T;
  char* current;
	int i=0;
	if(L->Diffrend!=NULL){//Ean yparxoun klikes pou diaferoun me thn L
			C=L->Diffrend;	//Krataw thn TList me oles tis klikes pou diaferoun me thn L
			while(L->Next!=NULL){ //Gia kathe proion ths L
				L=L->Next;
				current=malloc(sizeof(char)*(strlen(L->name)+1));//apothikefsi tou trexon komvou
		    strcpy(current,L->name);
				N=C;
				while(N->Next!=NULL){ //Gia kathe lista pou diaferei
					N=N->Next;
					T=N->node;

					if(FindTList(Transfered,T)){ //Ean den exw elegksei thn T pio prin
						while(T->Next!=NULL){ //Gia kathe proion ths T klikas
							T=T->Next;
							fprintf(csvfile,"%s, %s\n",current,T->name);
							i++;
						}
					}

				}
				free(current);
			}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x30(%rbp)
movq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x328f
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x328f
movq %rdx, %rbx
leaq 0x30c2(%rip), %r15      # 0x62c0
movq %rax, -0x40(%rbp)
movq (%rax), %r13
movq %r13, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11a0
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x1060
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x3276
movq (%r13), %rax
cmpq $0x0, -0x30(%rbp)
je 0x3254
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x3254
cmpq %rax, (%rcx)
jne 0x3240
movq 0x8(%r13), %r13
jmp 0x322c
movq 0x18(%rax), %r14
testq %r14, %r14
je 0x324e
movq (%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1160
movq 0x18(%r14), %r14
jmp 0x3258
movq %r12, %rdi
callq 0x1030
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x31fe
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: FindTList
int FindTList(TList* L,CList* node){//Epistrefei 0 an iparxi to node sthn lista allios epistrefei 1
	if(L==NULL) return 1;
	while(L->Next!=NULL){
		L=L->Next;
		if(L->node==node) return 0;
	}
	return 1;
}

// Assembly:
movl $0x1, %eax
testq %rdi, %rdi
je 0x32bd
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x32bc
cmpq %rsi, (%rdi)
jne 0x32ac
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: Diff
void Diff(CList* F,CList* S){
	if(F->Diffrend==NULL){	//Ean h Diffrend ths F einai NULL dimiourgisethn kai vale mesa thn S
		F->Diffrend=CreateTList();
		InsertTList(F->Diffrend,S);
	}else{ //Allios an h S den einai mesa sthn Diffrend ths F vale thn mesa
		if(FindTList(F->Diffrend,S)) InsertTList(F->Diffrend,S);
	}

	if(S->Diffrend==NULL){//Ean h Diffrend ths S einai NULL dimiourgisethn kai vale mesa thn F
		S->Diffrend=CreateTList();
		InsertTList(S->Diffrend,F);
	}else{//Allios an h F den einai mesa sthn Diffrend ths S vale thn mesa
		if(FindTList(S->Diffrend,F)) InsertTList(S->Diffrend,F);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x32ef
movq %r15, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x3306
cmpq %r14, (%rax)
jne 0x32da
testq %rax, %rax
jne 0x331f
jmp 0x3306
movl $0x10, %edi
callq 0x11a0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x10(%rbx)
movl $0x10, %edi
callq 0x11a0
movq %r14, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
movq 0x10(%r14), %r15
testq %r15, %r15
je 0x3340
movq %r15, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x3357
cmpq %rbx, (%rax)
jne 0x332b
testq %rax, %rax
jne 0x3370
jmp 0x3357
movl $0x10, %edi
callq 0x11a0
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x10(%r14)
movl $0x10, %edi
callq 0x11a0
movq %rbx, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: InsertTList
void InsertTList(TList* L,CList* node){//Isagogi mias CList sthn TList
		TList* N;
		N=(TList*)malloc(sizeof(TList));
		N->node=node;
	  N->Next=L->Next;
	  L->Next=N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x11a0
movq %rbx, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: ReplaceTList
void ReplaceTList(TList* T,CList* P,CList* N){	//Antikathista mia CList sthn TList
	while(T->Next!=NULL){
		T=T->Next;
		if(T->node==P){
			T->node=N;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x34f4
cmpq %rsi, (%rdi)
jne 0x34e3
movq %rdx, (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: RemoveTList
void RemoveTList(TList* L,CList* C){	//Diagrafi mias CList apo thn TList
	TList* T;
	while(L->Next!=NULL){
		if(L->Next->node==C){
			T=L->Next;
			L->Next=T->Next;
			T->node=NULL;
			free(T);
			break;
		}
		L=L->Next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3520
cmpq %rsi, (%rdi)
jne 0x34fa
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rdi)
popq %rbp
jmp 0x1030
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: FreeTList
void FreeTList(TList* L){//Apodesmevi thn TList
  TList* T;
  while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
    T->node=NULL;
    free(T);
  }
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x354e
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq $0x0, (%rdi)
callq 0x1030
movq 0x8(%rbx), %rdi
jmp 0x352f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: FreeCList
void FreeCList(CList* L){//Apodesmevi thn CList
  CList* T;
	if(L->Diffrend!=NULL){
		FreeTList(L->Diffrend);
		L->Diffrend=NULL;
	}
  while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
    free(T->name);
    free(T);
  }
	free(L->name);
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3596
callq 0x3522
movq $0x0, 0x10(%rbx)
jmp 0x3596
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq (%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq 0x18(%rbx), %r14
testq %r14, %r14
jne 0x357e
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: SearchDiffList
int SearchDiffList(CList* C,CList* S){
	if(C==NULL || S==NULL) return 0;
	if(C==S) return 1;
	int ret;
	ret=FindTList(C->Diffrend,S);
	if(ret) return 0;
	return 1;
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x35f1
cmpq %rsi, %rdi
je 0x35ec
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x35f1
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x35ea
cmpq %rsi, (%rcx)
jne 0x35d7
movl $0x1, %eax
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: CreateTList
TList* CreateTList(){ //Dimiourgei mia nea TList
	TList *L;
	L=(TList *)malloc(sizeof(TList));
	L->Next=NULL;
  L->node=NULL;
	return L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x10, %edi
callq 0x11a0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: Print_Camera_Count_TList
void Print_Camera_Count_TList(TList* T)
{
	int i = 1;
	TList* tptr = T->Next;
	while(tptr != NULL)
	{
		printf("list %d has %d cameras\n", i, tptr->node->camera_count);
		tptr = tptr->Next;
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x365a
movl $0x1, %ebx
leaq 0x2c8b(%rip), %r14      # 0x62c8
movq (%r15), %rax
movl 0x20(%rax), %edx
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x10d0
incl %ebx
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x363d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: FreeeTList
void FreeeTList(TList* L){  //Apodesmevi thn TList kai tis CList pou exei os dedomena
	TList* T;
	while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
    FreeCList(T->node);
    free(T);
  }
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x3696
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rdi
callq 0x355c
movq %r14, %rdi
callq 0x1030
movq 0x8(%rbx), %r14
jmp 0x3673
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: CreateNList
NList* CreateNList(){ /*Dimiourgei mia nea WHash*/
	NList *L;
	L=(NList *)malloc(sizeof(NList));
	L->Next=NULL;
  L->camera=NULL;
	return L;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x30, %edi
callq 0x11a0
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %rcx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: InsertNList
void InsertNList(NList* L,char* camera){//Eisagei ena neo product sthn arxh ths NList
	NList *N;
  N=(NList*)malloc(sizeof(NList));
  N->camera=strdup(camera);
	N->clique=NULL;
	N->Spear=NULL;
	N->vector=NULL;
  N->Next=L->Next;
  L->Next=N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x11a0
movq %rax, %r15
movq %rbx, %rdi
callq 0x1270
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq $0x0, 0x18(%r15)
movq 0x20(%r14), %rax
movq %rax, 0x20(%r15)
movq %r15, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: ConectNList
CList* ConectNList(NList* L,char* product,CList* clique){//Eisagei ena neo product sthn arxh ths CList
	while(L->Next!=NULL){	//Vrisko ton komvo ston opio einai apothikevmeno to product
		L=L->Next;
		if(!strcmp(L->camera,product)){
				break;
		}
	}

	if(L->clique==NULL){	//Ean den einai to product idi se kapia klika

		if(clique==NULL){	//Ean den exei dwthei kapia klika wste na mpei ekei to product
			L->clique=CreateCList();	//Dimiourgise mia nea klika
			InsertCList(L->clique,product,L);	//Vale to product sthn nea klika
		}else{	//Ean exei dothei mia klika sthn opia prepei na valw afto kai tous komvous ths klikas tou
			L->clique=clique;	//O komvos pou einai apothikevmeno to product dixnei sthn klika pou dothike
			InsertCList(L->clique,product,L);	//vale to product sthn klika pou dothike
		}

	}else{	//Ean to product einai idi se kapia klika

		if(clique!=NULL){ //Ean exei dwthei kapia klika wste na mpei ekei to product
			if(L->clique!=clique){	//ean oi dio klikes den einai idies
					L->clique=AppendCList(clique,L->clique);	//sigxonevw tis dio klikes
			}
		}

	}
		return L->clique; //Epistrefo thn klika sthn opia evala to product
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r12, %rbx
movq 0x20(%r12), %r12
testq %r12, %r12
je 0x373e
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1140
movq %r12, %rbx
testl %eax, %eax
jne 0x371e
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x375f
testq %r14, %r14
je 0x379e
cmpq %r14, %rsi
je 0x379e
movq %r14, %rdi
callq 0x33a6
movq %r14, 0x10(%rbx)
jmp 0x379e
testq %r14, %r14
je 0x376d
movq %r14, 0x10(%rbx)
movq %r14, %rdi
jmp 0x3793
movl $0x28, %edi
callq 0x11a0
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %rax, 0x10(%rbx)
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x30d9
movq 0x10(%rbx), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: PrintNList
void PrintNList(NList* L){//Ektiponei thn NList
	printf("[");
  while(L->Next!=NULL){
    L=L->Next;
		printf(" %s ",L->camera );
	}
	printf("]\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x5b, %edi
callq 0x1040
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x37e5
leaq 0x2b11(%rip), %rbx      # 0x62e0
movq (%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10d0
movq 0x20(%r14), %r14
testq %r14, %r14
jne 0x37cf
leaq 0x2b0e(%rip), %rdi      # 0x62fa
popq %rbx
popq %r14
popq %rbp
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: TransferNList
void TransferNList(NList* L,TList* Transfered,FILE* csvfile){	//Metaferi ta dedomena  ths NList
  while(L->Next!=NULL){
    L=L->Next;
		if(L->clique!=NULL){
				if(FindTList(Transfered,L->clique)){//Ean h klika pou dixnei o komvos L den exei metaferthi
						TransferCList(L->clique,csvfile);
						InsertTList(Transfered,L->clique);//Vale thn klika pou dixnei o komvos L se aftes pou exoun metaferthei
				}
  		}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x385e
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x3855
testq %r14, %r14
je 0x3830
movq %r14, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x3830
cmpq %rdi, (%rax)
jne 0x3820
jmp 0x3855
movq %rbx, %rsi
callq 0x3139
movq 0x10(%r15), %r12
movl $0x10, %edi
callq 0x11a0
movq %r12, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x380f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: DiffNList
void DiffNList(NList* L,TList* Transfered,FILE* csvfile){	//Metaferi ta dedomena  ths NList
  while(L->Next!=NULL){
    L=L->Next;
		if(L->clique!=NULL){
				if(FindTList(Transfered,L->clique)){//Ean h klika pou dixnei o komvos L den exei metaferthi
						DiffCList(L->clique,Transfered,csvfile);
						InsertTList(Transfered,L->clique);//Vale thn klika pou dixnei o komvos L se aftes pou exoun metaferthei
				}
  	}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x38d3
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x38ca
testq %r14, %r14
je 0x38a2
movq %r14, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x38a2
cmpq %rdi, (%rax)
jne 0x3892
jmp 0x38ca
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31c1
movq 0x10(%r15), %r12
movl $0x10, %edi
callq 0x11a0
movq %r12, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x3881
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: FreeNList
void FreeNList(NList* L,TList* Deleted){//Apodesmevi thn NList
	NList* T;
  while(L->Next!=NULL){
    T=L->Next;
    L->Next=T->Next;
		if(T->Spear!=NULL) FreeWHash(T->Spear);
		if(T->vector!=NULL)FreeHVector(T->vector);
    if(T->camera!=NULL) free(T->camera);
		if(T->clique!=NULL){
			if(FindTList(Deleted,T->clique)){//Ean h klika pou dixnei o komvos L den exei ektipothei
				InsertTList(Deleted,T->clique);//Vale thn klika pou dixnei o komvos L stis ektipomenes
			}
		}
		free(T);
  }
  free(L);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x3972
movq %rsi, %r14
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x390c
callq 0x3982
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x391a
callq 0x1030
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3927
callq 0x1030
movq 0x10(%r15), %r12
testq %r12, %r12
je 0x3961
testq %r14, %r14
je 0x3948
movq %r14, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x3948
cmpq %r12, (%rax)
jne 0x3938
jmp 0x3961
movl $0x10, %edi
callq 0x11a0
movq %r12, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
movq %r15, %rdi
callq 0x1030
movq 0x20(%rbx), %r15
testq %r15, %r15
jne 0x38f6
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: FreeWHash
void FreeWHash(WHash* H){   //apodesmefsth tou Hash
  for(int i=0 ; i<H->size ; i++){
    if(H[i].word!=NULL) free(H[i].word);
  }
  free(H);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x14(%rdi)
jle 0x39b9
leaq 0x8(%rbx), %r14
xorl %r15d, %r15d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x39a9
callq 0x1030
incq %r15
movslq 0x14(%rbx), %rax
addq $0x18, %r14
cmpq %rax, %r15
jl 0x399c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: CreateWHash
WHash* CreateWHash(int size){ //Dimiourgia enos neou WHash
	WHash *H;
	H=(WHash *)malloc(sizeof(WHash)*size);
	H->size=size;
	H->count=0;
	for(int i=0 ; i< size ; i++){//gia kathe bucket tou HashTable arxikopiise ta dedomena
		H[i].word=NULL;
		H[i].tfidf=0;
	}
	return H;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movslq %edi, %r14
leaq (,%r14,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x11a0
movl %r14d, 0x14(%rax)
movl $0x0, 0x10(%rax)
testl %r14d, %r14d
jle 0x3a1e
movl %ebx, %ecx
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x3a11
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: InsertWHash
WHash* InsertWHash(WHash* H,char* word){	//Eisagei ena neo value stho WHash
	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 whashf
      index=whashf(word,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 leksh
      break;
    }else if(!strcmp(H[index].word,word)){  //Ean iparxi idi tha vgoume ap thn epanalipsh
      exist=1;
      break;
    }
  }
  if(!exist){ //Ean h leksh den iparxei idi
    H->count++;
    H[index].word=strdup(word);
    H[index].tfidf=1;
    float n=(1.0*H->count)/H->size;
    if(n>=0.8){ //Ean h plirotita ftasei to 80% kanei rehash
      H=Wrehash(H);
    }
  }else{	//Ean iparxi afksise to tf kata ena
    H[index].tfidf=H[index].tfidf+1;
  }
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rsi), %r15
movb $0x1, %cl
testb $0x1, %cl
je 0x3a6a
movb (%r14), %dl
testb %dl, %dl
je 0x3a80
movl $0x1505, %esi           # imm = 0x1505
movq %r15, %rcx
movl %esi, %eax
movsbl %dl, %edx
shll $0x5, %eax
addl %esi, %eax
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
movl %eax, %esi
testb %dl, %dl
jne 0x3a53
jmp 0x3a85
incl %r13d
movl 0x14(%rbx), %eax
cmpl %eax, %r13d
movl $0x0, %ecx
cmovll %ecx, %eax
subl %eax, %r13d
jmp 0x3a93
movl $0x1505, %eax           # imm = 0x1505
cltd
idivl 0x14(%rbx)
movl %edx, %r13d
negl %r13d
cmovsl %edx, %r13d
movslq %r13d, %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,8), %r12
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x3acc
movq %r14, %rsi
callq 0x1140
xorl %ecx, %ecx
testl %eax, %eax
jne 0x3a3d
movsd (%r12), %xmm0
addsd 0x2754(%rip), %xmm0     # 0x6218
movsd %xmm0, (%r12)
jmp 0x3b12
movl 0x10(%rbx), %r15d
incl %r15d
movl %r15d, 0x10(%rbx)
movq %r14, %rdi
callq 0x1270
movq %rax, 0x8(%r12)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%r12)
cvtsi2sd %r15d, %xmm0
cvtsi2sdl 0x14(%rbx), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd 0x2790(%rip), %xmm0     # 0x62a0
jae 0x3b24
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b76
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: whashf
int whashf(char *str,int size){ //Hash sinartisi gia strings
  int hash = 5381;
  int c;
  while ((c = *str++))
    hash = ((hash << 5) + hash) + c; /* hash * 33 + c */

  return abs(hash % size);;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x3b66
pushq %rbp
movq %rsp, %rbp
incq %rdi
movl $0x1505, %edx           # imm = 0x1505
movl %edx, %eax
movsbl %cl, %ecx
shll $0x5, %eax
addl %edx, %eax
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
movl %eax, %edx
testb %cl, %cl
jne 0x3b4e
popq %rbp
jmp 0x3b6b
movl $0x1505, %eax           # imm = 0x1505
cltd
idivl %esi
movl %edx, %eax
negl %eax
cmovsl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: Wrehash
WHash* Wrehash(WHash* H){
  WHash*  Temp;
  int i,index,j;
  Temp=(WHash* )malloc( (H->size*2) *  sizeof(WHash) ); //Dimiourgo ena neo HasTable me thn diplasia xoritikotita
  Temp->size=H->size * 2;
  Temp->count=H->count;
  for(i=0 ; i< Temp->size ; i++){
    Temp[i].word=NULL;
    Temp[i].tfidf=0.0;
  }
  for(i=0 ; i< H->size ; i++){  //Pernaw ta dedomena tou paliou sto neo HasTable

    if(H[i].word!=NULL){  //Ean to arxiko Hash exei dedomena se afthn thn thesh
      j=0;
      while(1){ //Evresi tou bucket pou tha paei to neo product
        if(!j){ //Sthn proth epanalipsh ipologizoume mono thn sinartish hash
          index=whashf(H[i].word,Temp->size);
					j=1;
        }else{
          index++;
					if(index>=Temp->size) index-=Temp->size;
        }
        if(Temp[index].word==NULL){  //Ean einai adio to bucket tha isagoume se afto thn camera
          break;
        }
      }
			//Antigrafi twn dedomenwn
      Temp[index].word=strdup(H[i].word);
      Temp[index].tfidf=H[i].tfidf;
    }
  }
  FreeWHash(H);
  return Temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
movslq 0x14(%rdi), %rbx
leal (%rbx,%rbx), %r12d
movq %rbx, %rax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
callq 0x11a0
movq %rax, %r14
movl %r12d, 0x14(%rax)
movl 0x10(%r13), %eax
movl %eax, 0x10(%r14)
movq %rbx, -0x30(%rbp)
testq %rbx, %rbx
jle 0x3be2
cmpl $0x2, %r12d
movl $0x1, %eax
cmovgel %r12d, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%rcx)
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x3bd4
cmpl $0x0, -0x30(%rbp)
jle 0x3cb1
xorl %r9d, %r9d
xorl %r15d, %r15d
movq %r13, -0x38(%rbp)
leaq (%r15,%r15,2), %rax
movq 0x8(%r13,%rax,8), %rdi
testq %rdi, %rdi
je 0x3ca4
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, -0x40(%rbp)
leaq 0x1(%rdi), %rcx
movb $0x1, %al
testb $0x1, %al
je 0x3c51
movb (%rdi), %sil
testb %sil, %sil
je 0x3c61
movl $0x1505, %r8d           # imm = 0x1505
movq %rcx, %rdx
movl %r8d, %eax
movsbl %sil, %esi
shll $0x5, %eax
addl %r8d, %eax
addl %esi, %eax
movb (%rdx), %sil
incq %rdx
movl %eax, %r8d
testb %sil, %sil
jne 0x3c35
jmp 0x3c66
incl %ebx
cmpl %r12d, %ebx
movl %r12d, %eax
cmovll %r9d, %eax
subl %eax, %ebx
jmp 0x3c71
movl $0x1505, %eax           # imm = 0x1505
cltd
idivl %r12d
movl %edx, %ebx
negl %ebx
cmovsl %edx, %ebx
movslq %ebx, %rax
leaq (%rax,%rax,2), %rdx
xorl %eax, %eax
cmpq $0x0, 0x8(%r14,%rdx,8)
jne 0x3c1d
leaq (%r14,%rdx,8), %r13
callq 0x1270
xorl %r9d, %r9d
movq %rax, 0x8(%r13)
movq -0x40(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%r13)
movq -0x38(%rbp), %r13
incq %r15
cmpq -0x30(%rbp), %r15
jne 0x3bf6
movq %r13, %rdi
callq 0x3982
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: WHashTF
WHash* WHashTF(WHash* H ){
	int count=WHashCount(H);	//Apothikevi to sinolo olwn twn leksewn ths cameras
	for(int i=0 ; i<H->size ; i++){
		if(H[i].word!=NULL){	//Gia kathe bucket pou periexei mia leksh
			H[i].tfidf=(H[i].tfidf)/count;	//Ipologizw to tf gia thn antistih leksh
		}
	}
	return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movslq 0x14(%rdi), %rcx
testq %rcx, %rcx
jle 0x3d15
leaq (,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq $0x0, 0x8(%rax,%rsi)
je 0x3d03
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
addsd (%rax,%rsi), %xmm0
cvttsd2si %xmm0, %edi
addq $0x18, %rsi
cmpq %rsi, %rdx
jne 0x3ceb
xorps %xmm0, %xmm0
cvtsi2sd %edi, %xmm0
jmp 0x3d19
xorpd %xmm0, %xmm0
testl %ecx, %ecx
jle 0x3d46
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
xorl %edx, %edx
cmpq $0x0, 0x8(%rax,%rdx)
je 0x3d3d
movsd (%rax,%rdx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x3d27
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: WHashCount
int WHashCount(WHash* H){	//Ipologizei to sinoliko athrisma twn leksewn mias cameras
	int count=0;
	for(int i=0 ; i<H->size ; i++){
		if(H[i].word!=NULL){
			count+=H[i].tfidf;
		}
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x14(%rdi), %rax
testq %rax, %rax
jle 0x3d84
shlq $0x3, %rax
leaq (%rax,%rax,2), %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq $0x0, 0x8(%rdi,%rdx)
je 0x3d79
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
addsd (%rdi,%rdx), %xmm0
cvttsd2si %xmm0, %eax
addq $0x18, %rdx
cmpq %rdx, %rcx
jne 0x3d61
jmp 0x3d86
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: WHashFind
int WHashFind(WHash* H,char* word){ //Epistrefei 1 an iparxei  leksh sto hash allios 0
	int index,exist=0,j=0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %r15
movb $0x1, %cl
xorl %r12d, %r12d
testb $0x1, %cl
je 0x3dd1
movb (%rbx), %dl
testb %dl, %dl
je 0x3de4
movl $0x1505, %esi           # imm = 0x1505
movq %r15, %rcx
movl %esi, %eax
movsbl %dl, %edx
shll $0x5, %eax
addl %esi, %eax
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
movl %eax, %esi
testb %dl, %dl
jne 0x3dba
jmp 0x3de9
incl %r13d
movl 0x14(%r14), %eax
cmpl %eax, %r13d
cmovll %r12d, %eax
subl %eax, %r13d
jmp 0x3df8
movl $0x1505, %eax           # imm = 0x1505
cltd
idivl 0x14(%r14)
movl %edx, %r13d
negl %r13d
cmovsl %edx, %r13d
movslq %r13d, %rax
leaq (%rax,%rax,2), %rax
movq 0x8(%r14,%rax,8), %rdi
testq %rdi, %rdi
je 0x3e1e
movq %rbx, %rsi
callq 0x1140
xorl %ecx, %ecx
testl %eax, %eax
jne 0x3da5
movl $0x1, %eax
jmp 0x3e20
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_O1/DVaronos[P]AnLogProject1/list.c
// Function: GiveTfIdf
double GiveTfIdf(WHash* H,char* camera){ //Epistrefei thn timh tou tf an iparxei h leksh allios 0
	int index,j=0;

  while(1){
    if(!j){
      index=whashf(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)){
      return H[index].tfidf;
      break;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1(%rsi), %r15
movb $0x1, %cl
testb $0x1, %cl
je 0x3e76
movb (%r14), %dl
testb %dl, %dl
je 0x3e8c
movl $0x1505, %esi           # imm = 0x1505
movq %r15, %rcx
movl %esi, %eax
movsbl %dl, %edx
shll $0x5, %eax
addl %esi, %eax
addl %edx, %eax
movb (%rcx), %dl
incq %rcx
movl %eax, %esi
testb %dl, %dl
jne 0x3e5f
jmp 0x3e91
incl %r13d
movl 0x14(%rbx), %eax
cmpl %eax, %r13d
movl $0x0, %ecx
cmovll %ecx, %eax
subl %eax, %r13d
jmp 0x3e9f
movl $0x1505, %eax           # imm = 0x1505
cltd
idivl 0x14(%rbx)
movl %edx, %r13d
negl %r13d
cmovsl %edx, %r13d
movslq %r13d, %rax
leaq (%rax,%rax,2), %r12
movq 0x8(%rbx,%r12,8), %rdi
testq %rdi, %rdi
je 0x3ec8
movq %r14, %rsi
callq 0x1140
xorl %ecx, %ecx
testl %eax, %eax
jne 0x3e49
leaq (%rbx,%r12,8), %rax
movsd (%rax), %xmm0
jmp 0x3ecb
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: PrintWHash
void PrintWHash(WHash* H){
	int c=0;
	for(int i=0 ; i<H->size ; i++){
		if(H[i].word!=NULL){
			c++;
			printf("	%dh:%s-%f\n",c,H[i].word,H[i].tfidf);
		}
	}
}

// Assembly:
cmpl $0x0, 0x14(%rdi)
jle 0x3f40
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
xorl %r13d, %r13d
leaq 0x23e6(%rip), %r14      # 0x62e5
xorl %r15d, %r15d
movq (%r12), %rdx
testq %rdx, %rdx
je 0x3f22
incl %r15d
movsd -0x8(%r12), %xmm0
movq %r14, %rdi
movl %r15d, %esi
movb $0x1, %al
callq 0x10d0
incq %r13
movslq 0x14(%rbx), %rax
addq $0x18, %r12
cmpq %rax, %r13
jl 0x3f02
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: HVhash
int HVhash(int id,int size){
  id^= (id << 13);
  id^= (id >> 17);
  id^= (id << 5);
  return abs(id) % size;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0xd, %eax
xorl %edi, %eax
movl %eax, %ecx
sarl $0x11, %ecx
xorl %eax, %ecx
movl %ecx, %edx
shll $0x5, %edx
xorl %ecx, %edx
movl %edx, %eax
negl %eax
cmovsl %edx, %eax
cltd
idivl %esi
movl %edx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: CreateHVector
HVector* CreateHVector(int size){ //Dimiourgia enos neou WHash
	HVector *H;
	H=(HVector *)malloc(sizeof(HVector)*size);
	H->size=size;
	H->count=0;
	H->sum=0;
	for(int i=0 ; i< size ; i++){//gia kathe bucket tou HashTable arxikopiise ta dedomena
		H[i].key=-1;
		H[i].value=0;
	}
	return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movslq %edi, %r14
movq %r14, %rdi
shlq $0x5, %rdi
callq 0x11a0
movl %r14d, 0x1c(%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
testl %r14d, %r14d
jle 0x3fb9
movl %ebx, %ecx
shlq $0x5, %rcx
xorl %edx, %edx
movl $0xffffffff, (%rax,%rdx) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rax,%rdx)
addq $0x20, %rdx
cmpq %rdx, %rcx
jne 0x3fa0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: InsertHVector
HVector* InsertHVector(HVector* H,int key,double value){	//Eisagei ena neo value stho WHash
	int index,j=0;

  while(1){ //Evresi tou bucket pou tha paei to neo product
    if(!j){ //Sthn proth epanalipsh ipologizoume mono thn sinartish whashf
      index=HVhash(key,H->size);
			j=1;
    }else{
      index++;
			if(index>=H->size) index-=H->size;
    }
    if(H[index].key==-1){  //Ean einai adio to bucket tha isagoume se afto thn leksh
			H->count++;
			(H->sum)+=value;
			H[index].key=key;
			H[index].value=value;
      break;
    }
  }
  float n=(1.0*H->count)/H->size;
  if(n>=0.8){ //Ean h plirotita ftasei to 80% kanei rehash
      H=HVrehash(H);
  }
  return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
shll $0xd, %eax
xorl %esi, %eax
movl %eax, %ecx
sarl $0x11, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0x5, %eax
xorl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movb $0x1, %r9b
xorl %r8d, %r8d
testb $0x1, %r9b
je 0x3ff2
movl %ecx, %eax
cltd
idivl 0x1c(%rdi)
jmp 0x3fff
incl %edx
movl 0x1c(%rdi), %eax
cmpl %eax, %edx
cmovll %r8d, %eax
subl %eax, %edx
movslq %edx, %rax
shlq $0x5, %rax
xorl %r9d, %r9d
cmpl $-0x1, (%rdi,%rax)
jne 0x3fe4
addq %rdi, %rax
movl 0x18(%rdi), %ecx
incl %ecx
movl %ecx, 0x18(%rdi)
movsd 0x10(%rdi), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rdi)
movl %esi, (%rax)
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
cvtsi2sd %ecx, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x1c(%rdi), %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd 0x224e(%rip), %xmm0     # 0x62a0
jae 0x4059
movq %rdi, %rax
popq %rbp
retq
popq %rbp
jmp 0x405f
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: HVrehash
HVector* HVrehash(HVector* H){
  HVector*  Temp;
  int i;
  Temp=(HVector* )malloc( (H->size*1.5) *  sizeof(HVector) ); //Dimiourgo ena neo HasTable me thn diplasia xoritikotita
  Temp->size=H->size * 1.5;
  Temp->count=0;
	Temp->sum=0;
  for(i=0 ; i< Temp->size ; i++){
    Temp[i].key=-1;
    Temp[i].value=0;
  }
  for(i=0 ; i< H->size ; i++){  //Pernaw ta dedomena tou paliou sto neo HasTable

    if(H[i].key!=-1)  //Ean to arxiko Hash exei dedomena se afthn thn thesh
      Temp=InsertHVector(Temp,H[i].key,H[i].value);
  }

  FreeHVector(H);
  return Temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cvtsi2sdl 0x1c(%rdi), %xmm1
mulsd 0x222a(%rip), %xmm1     # 0x62a8
movsd %xmm1, -0x28(%rbp)
movsd 0x2225(%rip), %xmm0     # 0x62b0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x2215(%rip), %xmm0     # 0x62b8
cvttsd2si %xmm0, %rdi
andq %rcx, %rdi
orq %rax, %rdi
callq 0x11a0
movq %rax, %r14
cvttsd2si -0x28(%rbp), %eax
movl %eax, 0x1c(%r14)
movl $0x0, 0x18(%r14)
movq $0x0, 0x10(%r14)
testl %eax, %eax
jle 0x40f5
movl %eax, %eax
shlq $0x5, %rax
xorl %ecx, %ecx
movl $0xffffffff, (%r14,%rcx) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%r14,%rcx)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x40db
cmpl $0x0, 0x1c(%rbx)
jle 0x412b
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
movl -0x8(%r15), %esi
cmpl $-0x1, %esi
je 0x411b
movsd (%r15), %xmm0
movq %r14, %rdi
callq 0x3fbe
movq %rax, %r14
incq %r12
movslq 0x1c(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x4102
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: HVSumValues
double HVSumValues(HVector* H){
		double sum=0;
		for(int i=0 ; i<H->size ; i++){
			if(H[i].key!=-1) sum+=H[i].value;
		}
		return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x1c(%rdi), %rax
testq %rax, %rax
jle 0x4171
shlq $0x5, %rax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
cmpl $-0x1, (%rdi,%rcx)
je 0x4166
addsd 0x8(%rdi,%rcx), %xmm0
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x415a
jmp 0x4175
xorpd %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: HVGetValue
double HVGetValue(HVector* H,int key){
	int index,j=0;

  while(1){ //Evresi tou bucket pou tha paei to neo product
    if(!j){ //Sthn proth epanalipsh ipologizoume mono thn sinartish whashf
      index=HVhash(key,H->size);
    }else{
      index++;
			if(index>=H->size) index-=H->size;
    }
    if(H[index].key==key){  //Ean einai adio to bucket tha isagoume se afto thn leks
			return H[index].value;
      break;
    }
  }
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
shll $0xd, %eax
xorl %esi, %eax
movl %eax, %ecx
sarl $0x11, %ecx
xorl %eax, %ecx
movl %ecx, %edx
shll $0x5, %edx
xorl %ecx, %edx
movl %edx, %eax
negl %eax
cmovsl %edx, %eax
cltd
idivl 0x1c(%rdi)
shlq $0x5, %rdx
cmpl %esi, (%rdi,%rdx)
jne 0x41ae
addq %rdx, %rdi
movsd 0x8(%rdi), %xmm0
popq %rbp
retq
jmp 0x41ae
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/list.c
// Function: PrintHVector
void PrintHVector(HVector* H){
	int c=0;
	printf("[");
	for(int i=0; i<H->size ;i++){
		if(H[i].key!=-1){
			c++;
			printf("(%d-%f),",H[i].key,H[i].value);
		}
		if(c==H->count) break;
	}
	printf("]\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x5b, %edi
callq 0x1040
cmpl $0x0, 0x1c(%rbx)
jle 0x4213
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
leaq 0x2112(%rip), %r14      # 0x62f1
xorl %r13d, %r13d
movl -0x8(%r15), %esi
cmpl $-0x1, %esi
je 0x41fd
incl %r13d
movsd (%r15), %xmm0
movq %r14, %rdi
movb $0x1, %al
callq 0x10d0
cmpl 0x18(%rbx), %r13d
je 0x4213
incq %r12
movslq 0x1c(%rbx), %rax
addq $0x20, %r15
cmpq %rax, %r12
jl 0x41e2
leaq 0x20e0(%rip), %rdi      # 0x62fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/hash.c
// Function: hash
int hash(int id,int size){
  id^= (id << 13);
  id^= (id >> 17);
  id^= (id << 5);
  return abs(id % size);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0xd, %eax
xorl %edi, %eax
movl %eax, %ecx
sarl $0x11, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0x5, %eax
xorl %ecx, %eax
cltd
idivl %esi
movl %edx, %eax
negl %eax
cmovsl %edx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/hash.c
// Function: HashCreate
Hash* HashCreate(int size){ //Dimiourgei ena neo HashTable megetous size
  int i;
	Hash *H;
	H=(Hash* )malloc(size *  sizeof(Hash) );
	H->size=size;
  H->count=0;

  for(i=0 ; i< size ; i++){//gia kathe bucket tou HashTable dimiourgise mia nea NList
		H[i].Head=CreateNList();
	}
	return H;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %r14d
movslq %edi, %r15
movq %r15, %rdi
shlq $0x4, %rdi
callq 0x11a0
movq %rax, %rbx
movl %r15d, (%rax)
movl $0x0, 0x4(%rax)
testl %r15d, %r15d
jle 0x42a2
movl %r14d, %r14d
shlq $0x4, %r14
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x36a2
movq %rax, 0x8(%rbx,%r15)
addq $0x10, %r15
cmpq %r15, %r14
jne 0x428d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/DVaronos[P]AnLogProject1/hash.c
// Function: FreeHash
void FreeHash(Hash* H){//Apodesmevi to HashTable
  int i;
  TList* Deleted=CreateTList();
	for(i=0 ; i< H->size ; i++){
		FreeNList(H[i].Head,Deleted);
	}
  free(H);
  FreeeTList(Deleted);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x35f2
movq %rax, %r14
cmpl $0x0, (%rbx)
jle 0x42ee
leaq 0x8(%rbx), %r15
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r14, %rsi
callq 0x38dc
incq %r12
movslq (%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x42d4
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3665