indentations, minor changes

preprocessing/dpfgen.h

@@ -183,7 +183,7 @@ static inline void traverse(const prgkey_t & prgkey, const node_t & seed,	node_t
  */
 inline void create_dpfs (size_t db_nitems,
 						 const AES_KEY& prgkey,  uint8_t target_share[64], std::vector<socket_t>& socketsPb, std::vector<socket_t>& socketsP2,
-						 const size_t from, const size_t to, __m128i * output, int8_t * _t, __m128i& final_correction_word, bool party, size_t socket_no, size_t ind = 0)
+						 const size_t from, const size_t to, __m128i * output, int8_t * _t, __m128i& final_correction_word, dpfP2 * dpf_instance   ,bool party, size_t socket_no, size_t ind = 0)
 {
     const size_t bits_per_leaf = std::is_same<leaf_t, bool>::value ? 1 : sizeof(leaf_t) * CHAR_BIT;
 	const bool  is_packed = (sizeof(leaf_t) < sizeof(node_t));
@@ -197,7 +197,7 @@ inline void create_dpfs (size_t db_nitems,
 	
 	arc4random_buf(&root, sizeof(root));
     
-    root =	set_lsb(root, party);
+ root =	set_lsb(root, party);
 
 	const size_t from_node = std::floor(static_cast<double>(from) / nodes_per_leaf);
 
@@ -224,8 +224,8 @@ inline void create_dpfs (size_t db_nitems,
 	#endif
 
  
-	dpfP2 dpf_instance;
-	dpf_instance.root = root;
+ 
+	dpf_instance[ind].root = root;
 	for (size_t layer = 0; layer < depth; ++layer)
 	{
 			#ifdef VERBOSE	
@@ -276,9 +276,9 @@ inline void create_dpfs (size_t db_nitems,
 				}
 			#endif
 
-			dpf_instance.CW[layer] 		=  CW[layer];
-			dpf_instance.cwt_L[layer]   =  cwt_L;
-			dpf_instance.cwt_R[layer]   =  cwt_R;
+			dpf_instance[ind].CW[layer] 		=  CW[layer];
+			dpf_instance[ind].cwt_L[layer]   =  cwt_L;
+			dpf_instance[ind].cwt_R[layer]   =  cwt_R;
 			
 			for(size_t j = 0; j < nodes_in_prev_layer; ++j)
 			{	
@@ -289,7 +289,7 @@ inline void create_dpfs (size_t db_nitems,
 			}
 	}
  
-	boost::asio::write(socketsP2[socket_no+1], boost::asio::buffer(&dpf_instance, sizeof(dpfP2)));
+	boost::asio::write(socketsP2[socket_no+1], boost::asio::buffer(&dpf_instance[ind], sizeof(dpfP2)));
 	 
 	__m128i Gamma  =  _mm_setzero_si128();
 	 

preprocessing/filesio.h

@@ -1,4 +1,4 @@
-void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  int8_t ** flags, int64_t * outs_, __m128i * final_correction_word)
+void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  int8_t * flags, int64_t * outs_, __m128i  final_correction_word)
 {
  if(!party) 
  {  
@@ -8,7 +8,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
 	  int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   int written = write(w0, flags[i], db_nitems * sizeof(flags[i][0]));
+   int written = write(w0, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w0);
 
@@ -16,7 +16,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
    strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w1 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w1, flags[i], db_nitems * sizeof(flags[i][0]));
+   written = write(w1, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w1);
 	
@@ -24,7 +24,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w2 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w2, flags[i], db_nitems * sizeof(flags[i][0]));   
+   written = write(w2, flags, db_nitems * sizeof(flags[0]));   
 	  if(written<0)  perror("Write error"); 
 	  close(w2);
 
@@ -33,7 +33,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	 	strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w4, flags[i], db_nitems * sizeof(flags[i][0]));
+   written = write(w4, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w4);
 
@@ -41,7 +41,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
    strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w5, flags[i], db_nitems * sizeof(flags[i][0]));
+   written = write(w5, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w5);
 	  
@@ -49,7 +49,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w6, flags[i], db_nitems * sizeof(flags[i][0]));
+   written = write(w6, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error");    
 	  close(w6);
 
@@ -86,7 +86,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   int written = write(w0, flags[i], db_nitems * sizeof(flags[i][0]));
+   int written = write(w0, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w0);	
 
@@ -94,7 +94,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());	 
 	  int w1 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-	  written = write(w1, flags[i], db_nitems * sizeof(flags[i][0]));
+	  written = write(w1, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w1);
 
@@ -102,7 +102,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str()); 	  
 	  int w2 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w2,flags[i], db_nitems * sizeof(flags[i][0]));    
+   written = write(w2,flags, db_nitems * sizeof(flags[0]));    
    if(written<0)  perror("Write error");      
    close(w2);
 
@@ -111,7 +111,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());  
 	  int w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w4,flags[i], db_nitems * sizeof(flags[i][0]));
+   written = write(w4,flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w4);
 
@@ -119,7 +119,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
 	  strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());
    int w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w5, flags[i], db_nitems * sizeof(flags[i][0]));
+   written = write(w5, flags, db_nitems * sizeof(flags[0]));
    if(written<0)  perror("Write error"); 
    close(w5);
 	
@@ -127,7 +127,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
   	strcpy(tmp, p0_filename0);
  	 strcat(tmp, std::to_string(i).c_str());	   
 	  int w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   written = write(w6, flags[i], db_nitems * sizeof(flags[i][0]));    
+   written = write(w6, flags, db_nitems * sizeof(flags[0]));    
    if(written<0)  perror("Write error");    
 	  close(w6);
 
@@ -166,7 +166,7 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
  		strcat(tmp, std::to_string(i).c_str());
 		
 		 int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-		 int written = write(w0, &final_correction_word[0][0],  sizeof(final_correction_word[0][0]));
+		 int written = write(w0, &final_correction_word[0],  sizeof(uint64_t));
 		 if(written<0)	perror("Write error");
 		 close(w0);
 	}
@@ -180,11 +180,11 @@ void write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,  in
  	strcat(tmp, std::to_string(i).c_str());
 		
 		int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-		int written = write(w0, &final_correction_word[0][0],  sizeof(final_correction_word[0][0]));
+		int written = write(w0, &final_correction_word[0],  sizeof(uint64_t));
 		if(written<0) perror("Write error");
 		close(w0);
 	}
-
+ 
 }
 
 
@@ -194,80 +194,80 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 {
  if(!party) 
  {  
-    char const * p0_filename0;
-	   char tmp[100];
-   	p0_filename0 = "../duoram-online/preprocflags/P2_party0_read_flags_b";
-	   strcpy(tmp, p0_filename0);
- 	  strcat(tmp, std::to_string(i).c_str());
+   char const * p0_filename0;
+	  char tmp[100];
+   p0_filename0 = "../duoram-online/preprocflags/P2_party0_read_flags_b";
+	  strcpy(tmp, p0_filename0);
+ 	 strcat(tmp, std::to_string(i).c_str());
 	
-	   int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   	int written = write(w0, flags, db_nitems * sizeof(flags[i]));
-    if(written<0) perror("Write error");
-    close(w0);
+	  int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   int written = write(w0, flags, db_nitems * sizeof(int8_t));
+   if(written<0) perror("Write error");
+   close(w0);
 
- 	  p0_filename0 = "../duoram-online/preprocflags/P2_party0_read_flags_c";
-    strcpy(tmp, p0_filename0);
- 	  strcat(tmp, std::to_string(i).c_str());
-    int w1 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w1, flags, db_nitems * sizeof(flags[i]));
-    if(written<0) perror("Write error");
-    close(w1);
+ 	 p0_filename0 = "../duoram-online/preprocflags/P2_party0_read_flags_c";
+   strcpy(tmp, p0_filename0);
+ 	 strcat(tmp, std::to_string(i).c_str());
+   int w1 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w1, flags, db_nitems * sizeof(int8_t));
+   if(written<0) perror("Write error");
+   close(w1);
 	
-	   p0_filename0 = "../duoram-online/preprocflags/P2_party0_read_flags_d";
-	   strcpy(tmp, p0_filename0);
-   	strcat(tmp, std::to_string(i).c_str());
-    int w2 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w2, flags, db_nitems * sizeof(flags[i]));
-    if(written<0) perror("Write error");
-    close(w2);
+	  p0_filename0 = "../duoram-online/preprocflags/P2_party0_read_flags_d";
+	  strcpy(tmp, p0_filename0);
+   strcat(tmp, std::to_string(i).c_str());
+   int w2 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w2, flags, db_nitems * sizeof(int8_t));
+   if(written<0) perror("Write error");
+   close(w2);
 
- 	  p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_flags_b";
-	 	 strcpy(tmp, p0_filename0);
- 	  strcat(tmp, std::to_string(i).c_str());
-    int w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w4, flags, db_nitems * sizeof(flags[i]));
-    if(written<0) perror("Write error");
-    close(w4);
+ 	 p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_flags_b";
+	 	strcpy(tmp, p0_filename0);
+ 	 strcat(tmp, std::to_string(i).c_str());
+   int w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w4, flags, db_nitems * sizeof(int8_t));
+   if(written<0) perror("Write error");
+   close(w4);
 
-    p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_flags_c";
-    strcpy(tmp, p0_filename0);
- 	  strcat(tmp, std::to_string(i).c_str());
-    int w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w5, flags, db_nitems * sizeof(flags[i]));
-    if(written<0) perror("Write error");
-    close(w5);
+   p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_flags_c";
+   strcpy(tmp, p0_filename0);
+ 	 strcat(tmp, std::to_string(i).c_str());
+   int w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w5, flags, db_nitems * sizeof(int8_t));
+   if(written<0) perror("Write error");
+   close(w5);
 	  
-    p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_flags_d";
-	   strcpy(tmp, p0_filename0);
- 	  strcat(tmp, std::to_string(i).c_str());
-    int w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w6, flags, db_nitems * sizeof(flags[i]));
-    if(written<0) perror("Write error"); 
-	   close(w6);
+   p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_flags_d";
+	  strcpy(tmp, p0_filename0);
+ 	 strcat(tmp, std::to_string(i).c_str());
+   int w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w6, flags, db_nitems * sizeof(int8_t));
+   if(written<0) perror("Write error"); 
+	  close(w6);
 
-    p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_b";
-    strcpy(tmp, p0_filename0);
-    strcat(tmp, std::to_string(i).c_str());
-    w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w4, outs_, db_nitems * sizeof(outs_[i]));
-    if(written<0) perror("Write error"); 
-    close(w4);
+   p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_b";
+   strcpy(tmp, p0_filename0);
+   strcat(tmp, std::to_string(i).c_str());
+   w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w4, outs_, db_nitems * sizeof(int64_t));
+   if(written<0) perror("Write error"); 
+   close(w4);
 
- 	  p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_c";
-	   strcpy(tmp, p0_filename0);
- 	  strcat(tmp, std::to_string(i).c_str());
-    w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w5, outs_, db_nitems * sizeof(outs_[i]));
-    if(written<0) perror("Write error"); 
-    close(w5);
+ 	 p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_c";
+	  strcpy(tmp, p0_filename0);
+ 	 strcat(tmp, std::to_string(i).c_str());
+   w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w5, outs_, db_nitems * sizeof(int64_t));
+   if(written<0) perror("Write error"); 
+   close(w5);
 
-    p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_d";
-		  strcpy(tmp, p0_filename0);
-   	strcat(tmp, std::to_string(i).c_str());
-    w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w6, outs_, db_nitems * sizeof(outs_[i]));
-    if(written<0) perror("Write error"); 
- 	  close(w6);	  
+   p0_filename0 = "../duoram-online/preprocflags/P2_party0_write_d";
+		 strcpy(tmp, p0_filename0);
+   strcat(tmp, std::to_string(i).c_str());
+   w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
+   written = write(w6, outs_, db_nitems * sizeof(int64_t));
+   if(written<0) perror("Write error"); 
+ 	 close(w6);	  
   }
   
   if(party) 
@@ -279,7 +279,7 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
  	  strcat(tmp, std::to_string(i).c_str());
      
 	   int w0 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    int written = write(w0, flags, db_nitems * sizeof(flags[i]));
+    int written = write(w0, flags, db_nitems * sizeof(int8_t));
     if(written<0) perror("Write error");   
 	   close(w0);	
 
@@ -287,7 +287,7 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 	   strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());
    	int w1 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-	   written = write(w1, flags, db_nitems * sizeof(flags[i]));
+	   written = write(w1, flags, db_nitems * sizeof(int8_t));
 	   if(written<0)  perror("Write error");
     close(w1);
 
@@ -295,7 +295,7 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 	   strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());  
 	   int w2 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w2,flags, db_nitems * sizeof(flags[i]));
+    written = write(w2,flags, db_nitems * sizeof(int8_t));
     if(written<0)  perror("Write error"); 
     close(w2);
 
@@ -303,7 +303,7 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 	   strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());
 	   int w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w4,flags, db_nitems * sizeof(flags[i]));
+    written = write(w4,flags, db_nitems * sizeof(int8_t));
     if(written<0)  perror("Write error"); 
     close(w4);
 
@@ -311,7 +311,7 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 	   strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());
 	   int w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w5, flags, db_nitems * sizeof(flags[i]));
+    written = write(w5, flags, db_nitems * sizeof(int8_t));
     if(written<0)  perror("Write error"); 
     close(w5);
 	
@@ -319,7 +319,7 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
    	strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());   
 	   int w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-   	written = write(w6, flags, db_nitems * sizeof(flags[i]));  
+   	written = write(w6, flags, db_nitems * sizeof(int8_t));  
     if(written<0)  perror("Write error");   
    	close(w6);
 
@@ -327,15 +327,16 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 	   strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());
     w4 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w4, outs_, db_nitems * sizeof(outs_[i]));
+    written = write(w4, outs_, db_nitems * sizeof(int64_t));
     if(written<0)  perror("Write error"); 
     close(w4);
- 
+
+ 	//char const * p0_filename0;
     p0_filename0 = "../duoram-online/preprocflags/P2_party1_write_c";
    	strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());
     w5 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w5, outs_, db_nitems * sizeof(outs_[i]));
+    written = write(w5, outs_, db_nitems * sizeof(int64_t));
     if(written<0)  perror("Write error"); 
     close(w5);
 	
@@ -343,10 +344,12 @@ void P2_write_evalfull_outs_into_a_file(bool party, size_t i, size_t db_nitems,
 	   strcpy(tmp, p0_filename0);
  	  strcat(tmp, std::to_string(i).c_str());
     w6 = open( tmp, O_WRONLY | O_CREAT, S_IWRITE | S_IREAD);
-    written = write(w6, outs_, db_nitems * sizeof(outs_[i]));
+    written = write(w6, outs_, db_nitems * sizeof(int64_t));
     if(written<0)  perror("Write error");   
 	   close(w6);
   }
+
+ 
 }
 
 

preprocessing/p2preprocessing.cpp

@@ -48,10 +48,10 @@ size_t __depth(const size_t nitems) { return std::ceil(std::log2(std::ceil(stati
 #include "share-conversion.h"
 
 void mpc_gen(const size_t depth, AES_KEY& prgkey, const size_t db_nitems, const size_t n_threads, std::vector<socket_t>& sockets0, std::vector<socket_t>& sockets1, 
-             __m128i** output0, int8_t ** flags0,    __m128i** output1, int8_t ** flags1,   size_t j,
-            size_t socket_no = 0)
+             __m128i** output0, int8_t ** flags0, __m128i** output1, int8_t ** flags1, dpfP2 * dpf_instance0 , dpfP2 * dpf_instance1, size_t ind,
+             size_t socket_no = 0)
 {	
-	 dpfP2 dpf_instance0, dpf_instance1;
+
   
   for(size_t j = 0; j < depth; ++j)
   {
@@ -101,17 +101,17 @@ void mpc_gen(const size_t depth, AES_KEY& prgkey, const size_t db_nitems, const
 
   } 
   
-  boost::asio::read(sockets0[socket_no+1], boost::asio::buffer(&dpf_instance0, sizeof(dpfP2)));
-  boost::asio::read(sockets1[socket_no+1], boost::asio::buffer(&dpf_instance1, sizeof(dpfP2)));
+  boost::asio::read(sockets0[socket_no+1], boost::asio::buffer(&dpf_instance0[ind], sizeof(dpfP2)));
+  boost::asio::read(sockets1[socket_no+1], boost::asio::buffer(&dpf_instance1[ind], sizeof(dpfP2)));
  
 
-  evaluate_dpfs(db_nitems,  dpf_instance0,   prgkey,  0, db_nitems-1,	output0[j],  flags0[j],  false,  0);
-  evaluate_dpfs(db_nitems,  dpf_instance1,   prgkey,  0, db_nitems-1, output1[j],  flags1[j],  true ,  0);
+  evaluate_dpfs(db_nitems,  dpf_instance0[ind],   prgkey,  0, db_nitems-1,	output0[ind],  flags0[ind],  false,  ind);
+  evaluate_dpfs(db_nitems,  dpf_instance1[ind],   prgkey,  0, db_nitems-1, output1[ind],  flags1[ind],  true ,  ind);
 
 
   // P2_write_evalfull_outs_into_a_file(false, 0, db_nitems,  flags0[0], 	output0[0]);
   // P2_write_evalfull_outs_into_a_file(true,  0, db_nitems,  flags1[0], 	output1[0]);
-  #ifdef DEBUG
+ #ifdef DEBUG
     for(size_t j = 0; j < db_nitems; ++j)
     {
       std::cout << j << "-> "  << (int) flags0[0][j] << " <-> " << (int) flags1[0][j] << std::endl;
@@ -156,26 +156,27 @@ int main(int argc, char* argv[])
   }
 
 
-  std::vector<socket_t> sockets0;
-  std::vector<socket_t> sockets1;
-  sockets0.reserve(number_of_sockets + 1);
-  sockets1.reserve(number_of_sockets + 1);
+ std::vector<socket_t> sockets0;
+ std::vector<socket_t> sockets1;
+ sockets0.reserve(number_of_sockets + 1);
+ sockets1.reserve(number_of_sockets + 1);
 
-  boost::asio::thread_pool pool2(number_of_sockets * 2); 
-  for(size_t j = 0; j < number_of_sockets; ++j)
-  {
-    boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets1), ports2_1[j],  j));
-  }
+ boost::asio::thread_pool pool2(number_of_sockets * 2); 
+ 
+ for(size_t j = 0; j < number_of_sockets; ++j)
+ {
+   boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets1), ports2_1[j],  j));
+ }
 
   
-  for(size_t j = 0; j < number_of_sockets; ++j)
-  {
-    boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets0), ports2_0[j],  j));
-  }
+ for(size_t j = 0; j < number_of_sockets; ++j)
+ {
+  boost::asio::post(pool2, std::bind(accept_conncections_from_Pb,  std::ref(io_context), std::ref(sockets0), ports2_0[j],  j));
+ }
 
-  pool2.join();
+ pool2.join();
 
-  boost::asio::thread_pool pool(n_threads);  
+ boost::asio::thread_pool pool(n_threads);  
 
 	__m128i ** output0 = (__m128i ** ) malloc(sizeof(__m128i *) * n_threads);
 	int8_t  ** flags0  = (int8_t ** ) malloc(sizeof(uint8_t *) * n_threads);
@@ -196,33 +197,38 @@ int main(int argc, char* argv[])
 		output1[j] = (__m128i *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(__m128i));
 		flags1[j]  = (int8_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(uint8_t));
 	}
-  for(size_t j = 0; j < n_threads; ++j)
-  {
-     boost::asio::post(pool, std::bind(mpc_gen,  std::ref(depth), std::ref(aeskey), db_nitems, n_threads,  std::ref(sockets0), std::ref(sockets1), 
-                                       output0, flags0,  output1, flags1,  j, 5 * j));    
-  }
+ 
+ dpfP2 * dpf_instance0 = (dpfP2 * ) malloc (sizeof(dpfP2) * n_threads);
+ dpfP2 * dpf_instance1 = (dpfP2 * ) malloc (sizeof(dpfP2) * n_threads);
+ 
+ for(size_t j = 0; j < n_threads; ++j)
+ {
+   boost::asio::post(pool, std::bind(mpc_gen,  std::ref(depth), std::ref(aeskey), db_nitems, n_threads,  std::ref(sockets0), std::ref(sockets1), 
+                                       output0, flags0,  output1, flags1,  std::ref(dpf_instance0), std::ref(dpf_instance1), j, 5 * j));    
+ }
 
   pool.join();
 
 
   boost::asio::thread_pool pool3(n_threads); 
+  
   int64_t ** leaves0    = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads);
-	int64_t ** leafbits0  = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads); 
+	 int64_t ** leafbits0  = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads); 
   int64_t ** leaves1    = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads);
-	int64_t ** leafbits1  = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads); 
+	 int64_t ** leafbits1  = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads); 
 	
   for(size_t j = 0; j < n_threads; ++j)
-	{
-		leaves0[j]    = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
-		leafbits0[j]  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
-    leaves1[j]    = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
-		leafbits1[j]  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
-	}
+	 {
+		 leaves0[j]    = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+		 leafbits0[j]  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+   leaves1[j]    = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+		 leafbits1[j]  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+	 }
 
  /* The function convert_sharesP2 appears in share-conversion.h */
   for(size_t j = 0; j < n_threads; ++j)
   {
-     boost::asio::post(pool3, std::bind(convert_sharesP2, db_nitems,  output0, flags0,  output1, flags1, leaves0, leafbits0, leaves1, leafbits1,  std::ref(sockets0), std::ref(sockets1),j,  j));    
+   boost::asio::post(pool3, std::bind(convert_sharesP2, db_nitems,  output0, flags0,  output1, flags1, leaves0, leafbits0, leaves1, leafbits1,  std::ref(sockets0), std::ref(sockets1), j, j));    
   }
 
   pool3.join(); 
@@ -235,6 +241,28 @@ int main(int argc, char* argv[])
   }
   pool4.join();
 
+
+
+  for(size_t i = 0; i < n_threads; ++i)
+  {
+      P2_write_evalfull_outs_into_a_file(false, i, db_nitems,  flags0[i], 	leaves0[i]);
+      P2_write_evalfull_outs_into_a_file(true,  i, db_nitems,  flags1[i], 	leaves1[i]);
+  }
+
+  #ifdef DEBUG
+    for(size_t ind = 0; ind < n_threads; ++ind)
+    {
+     for(size_t j = 0; j < db_nitems; ++j)
+     {
+      if(flags0[ind][j] + flags1[ind][j] != 0)
+      {
+       std::cout << j << "-> "  << (int) (flags0[ind][j] + flags1[ind][j]) << " = " << (int) (flags0[ind][j])  << " + " << (int) (flags1[ind][j]) << std::endl;
+       std::cout << j << "-> " << output0[ind][j][0] << " <-> " << output1[ind][j][0] << std::endl << std::endl;
+      }
+     }
+   }
+  #endif
+  
   return 0;
 }
 

preprocessing/preprocessing.cpp

@@ -48,125 +48,135 @@ using namespace dpf;  // The namespace is found in bitutils.h
 
 int main(int argc, char * argv[])
 { 	
-	
-	boost::asio::io_context io_context;
-	std::string addr = "127.0.0.1";
-	
-	const std::string host1 = (argc < 2) ? "127.0.0.1" : argv[1];
-	const std::string host2 = (argc < 3) ? "127.0.0.1" : argv[2];
-	const size_t n_threads = atoi(argv[3]);
-	const size_t expo = atoi(argv[4]);
-	const size_t number_of_sockets = 5 * n_threads;
-
-	std::vector<socket_t> socketsPb, socketsP2;
-	std::vector<int> ports, ports2_1, ports2_0;
+    
+    boost::asio::io_context io_context;
+    std::string addr = "127.0.0.1";
+    
+    const std::string host1 = (argc < 2) ? "127.0.0.1" : argv[1];
+    const std::string host2 = (argc < 3) ? "127.0.0.1" : argv[2];
+    const size_t n_threads = atoi(argv[3]);
+    const size_t expo = atoi(argv[4]);
+    const size_t number_of_sockets = 5 * n_threads;
+
+    std::vector<socket_t> socketsPb, socketsP2;
+    std::vector<int> ports, ports2_1, ports2_0;
  
-  	bool party;
+      bool party;
 
-	/* The function make_connections appears in network.h */
-	make_connections(party, host1, host2,  io_context, socketsPb, socketsP2, ports,  ports2_1, ports2_0, number_of_sockets);
+    /* The function make_connections appears in network.h */
+    make_connections(party, host1, host2,  io_context, socketsPb, socketsP2, ports,  ports2_1, ports2_0, number_of_sockets);
  
-	const size_t db_nitems = 1ULL << atoi(argv[4]);
-
- 	auto start = std::chrono::steady_clock::now(); 
-	
-	uint8_t ** target_share_read = new uint8_t*[n_threads];
-
-	generate_random_targets(target_share_read,  n_threads, party, expo);
-	
-	AES_KEY aeskey;
-
-	__m128i * final_correction_word = (__m128i *) std::aligned_alloc(sizeof(__m256i), n_threads * sizeof(__m128i));
-	__m128i ** output = (__m128i ** ) malloc(sizeof(__m128i *) * n_threads);
-	int8_t  ** flags  = (int8_t ** ) malloc(sizeof(uint8_t *) * n_threads);
-	 
-	for(size_t j = 0; j < n_threads; ++j)
-	{
-		output[j] = (__m128i *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(__m128i));
-		flags[j]  = (int8_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(uint8_t));
-	}
-	 
-	boost::asio::thread_pool pool(n_threads);
-	boost::asio::thread_pool pool_share_conversion(n_threads);
-	
-
-	
-	// The following function call creates and evaluates DPFs at target_share_read[j] for j \in \{0, \ldots, n_threads}
-	// the flag vectors are stored in flags
-	// the leaves are stored in output
-	// the final correctionword is stored in final_correction_word
-
-	/* The function create_dpfs appears in dpf-gen.h*/
-	for(size_t j = 0; j < n_threads; ++j)
-	{
-		boost::asio::post(pool,  std::bind(create_dpfs,  db_nitems,	std::ref(aeskey),  target_share_read[j],  std::ref(socketsPb), std::ref(socketsP2), 0, db_nitems-1, 
-						  output[j],  flags[j], std::ref(final_correction_word[j]),  party, 5 * j, j));	 	  
-	}
-	pool.join();  
-
-	#ifdef DEBUG
-		for(size_t j = 0; j < n_threads; ++j)
-		{
-			for(size_t i = 0; i < db_nitems; ++i)
-			{
-				int8_t flags_reconstruction;
-				boost::asio::write(socketsPb[0], boost::asio::buffer(&flags[j][i], sizeof(flags[j][i])));
-				boost::asio::read(socketsPb[0], boost::asio::buffer(&flags_reconstruction, sizeof(flags_reconstruction)));
-				flags_reconstruction -= flags[j][i];
-				if(flags_reconstruction != 0) std::cout << i << " ---> " << (int) flags_reconstruction << std::endl;
-
-				int64_t output_reconstruction;
-				boost::asio::write(socketsPb[0], boost::asio::buffer(&output[j][i][0], sizeof(output[j][i][0])));
-				boost::asio::read(socketsPb[0], boost::asio::buffer(&output_reconstruction, sizeof(output_reconstruction)));
-				output_reconstruction -= output[j][i][0];
-				if(output_reconstruction != 0) std::cout << i << "---> " << output_reconstruction << std::endl;
-			}
-
-			int64_t final_correction_word_reconstruction = 0;
-			boost::asio::write(socketsPb[0], boost::asio::buffer(&final_correction_word[j][0], sizeof(final_correction_word[j][0])));
-			boost::asio::read(socketsPb[0], boost::asio::buffer(&final_correction_word_reconstruction, sizeof(final_correction_word_reconstruction)));
-			final_correction_word_reconstruction = final_correction_word_reconstruction + final_correction_word[j][0];
-			std::cout << "final_correction_word_reconstruction = " << final_correction_word_reconstruction << std::endl << std::endl;
-		}
-	#endif
+    const size_t db_nitems = 1ULL << atoi(argv[4]);
+
+     auto start = std::chrono::steady_clock::now(); 
+    
+    uint8_t ** target_share_read = new uint8_t*[n_threads];
+
+    generate_random_targets(target_share_read,  n_threads, party, expo);
+    
+    AES_KEY aeskey;
+
+    __m128i * final_correction_word = (__m128i *) std::aligned_alloc(sizeof(__m256i), n_threads * sizeof(__m128i));
+    __m128i ** output = (__m128i ** ) malloc(sizeof(__m128i *) * n_threads);
+    int8_t  ** flags  = (int8_t ** ) malloc(sizeof(uint8_t *) * n_threads);
+     
+    for(size_t j = 0; j < n_threads; ++j)
+    {
+        output[j] = (__m128i *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(__m128i));
+        flags[j]  = (int8_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(uint8_t));
+    }
+     
+    boost::asio::thread_pool pool(n_threads);
+    boost::asio::thread_pool pool_share_conversion(n_threads);
+    
+
+    
+    // The following function call creates and evaluates DPFs at target_share_read[j] for j \in \{0, \ldots, n_threads}
+    // the flag vectors are stored in flags
+    // the leaves are stored in output
+    // the final correctionword is stored in final_correction_word
+
+    dpfP2 * dpf_instance = (dpfP2 * ) malloc (sizeof(dpfP2) * n_threads);
+
+    /* The function create_dpfs appears in dpf-gen.h*/
+    for(size_t j = 0; j < n_threads; ++j)
+    {
+        boost::asio::post(pool,  std::bind(create_dpfs,  db_nitems,	std::ref(aeskey),  target_share_read[j],  std::ref(socketsPb), std::ref(socketsP2), 0, db_nitems-1, 
+                          output[j],  flags[j], std::ref(final_correction_word[j]), std::ref(dpf_instance),  party, 5 * j, j));	 	  
+    }
+    pool.join();  
+
+    #ifdef DEBUG
+        for(size_t j = 0; j < n_threads; ++j)
+        {
+   std::cout << "n_threads = " << j << std::endl;
+            for(size_t i = 0; i < db_nitems; ++i)
+            {
+                int8_t flags_reconstruction;
+                boost::asio::write(socketsPb[0], boost::asio::buffer(&flags[j][i], sizeof(flags[j][i])));
+                boost::asio::read(socketsPb[0], boost::asio::buffer(&flags_reconstruction, sizeof(flags_reconstruction)));
+                flags_reconstruction -= flags[j][i];
+                if(flags_reconstruction != 0) std::cout << i << " (flag) ---> " << (int) flags_reconstruction << std::endl;
+
+                int64_t output_reconstruction;
+                boost::asio::write(socketsPb[0], boost::asio::buffer(&output[j][i][0], sizeof(output[j][i][0])));
+                boost::asio::read(socketsPb[0], boost::asio::buffer(&output_reconstruction, sizeof(output_reconstruction)));
+                output_reconstruction -= output[j][i][0];
+                if(output_reconstruction != 0) std::cout << i << " (output) ---> " << output_reconstruction << std::endl;
+            }
+
+            int64_t final_correction_word_reconstruction = 0;
+            boost::asio::write(socketsPb[0], boost::asio::buffer(&final_correction_word[j][0], sizeof(final_correction_word[j][0])));
+            boost::asio::read(socketsPb[0], boost::asio::buffer(&final_correction_word_reconstruction, sizeof(final_correction_word_reconstruction)));
+            final_correction_word_reconstruction = final_correction_word_reconstruction + final_correction_word[j][0];
+            std::cout << "final_correction_word_reconstruction = " << final_correction_word_reconstruction << std::endl << std::endl;
+        }
+    #endif
  
 
 
 
-	/* 
-		leaves is a additive shares of the outputs (leaves of the DPF)
-		leafbits is the additive shares of flag bits of the DPFs
-	*/
-	int64_t ** leaves = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads);
-	int64_t ** leafbits  = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads); 
-	for(size_t j = 0; j < n_threads; ++j)
-	{
-		leaves[j] = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
-		leafbits[j]  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
-	}
-
-	/* The function convert_shares appears in share-conversion.h */
-	for(size_t j = 0; j < n_threads; ++j)
-	{
-		boost::asio::post(pool_share_conversion,  std::bind(convert_shares, j, output, flags, n_threads, db_nitems, final_correction_word, 	leaves, leafbits, 
-												  std::ref(socketsPb[j]), std::ref(socketsP2[j]), party ));	 	
-	}
-	
-	pool_share_conversion.join();
-
-
-	boost::asio::thread_pool pool_xor_to_additive(n_threads); 
-
-	for(size_t j = 0; j < n_threads; ++j)
-	{
- 		boost::asio::post(pool_xor_to_additive, std::bind(xor_to_additive, party, target_share_read[j], std::ref(socketsPb[j]), std::ref(socketsP2[j])));
-	}
-
-	pool_xor_to_additive.join();
-	
-	auto end = std::chrono::steady_clock::now();
-	std::chrono::duration<double> elapsed_seconds = end-start;
-	std::cout << "time to generate and evaluate " << n_threads << " dpfs of size 2^" << atoi(argv[4]) << " is: " << elapsed_seconds.count() << "s\n";
-	
-	return 0;
+    /* 
+        leaves is a additive shares of the outputs (leaves of the DPF)
+        leafbits is the additive shares of flag bits of the DPFs
+    */
+    int64_t ** leaves = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads);
+    int64_t ** leafbits  = (int64_t ** ) malloc(sizeof(int64_t *) * n_threads); 
+    for(size_t j = 0; j < n_threads; ++j)
+    {
+        leaves[j] = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+        leafbits[j]  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+    }
+
+
+
+    /* The function convert_shares appears in share-conversion.h */
+    for(size_t j = 0; j < n_threads; ++j)
+    {
+        boost::asio::post(pool_share_conversion,  std::bind(convert_shares, j, output, flags, n_threads, db_nitems, final_correction_word, 	leaves, leafbits, 
+                                                        std::ref(socketsPb), std::ref(socketsP2),  party ));	 	
+    }
+    
+    pool_share_conversion.join();
+
+
+    boost::asio::thread_pool pool_xor_to_additive(n_threads); 
+
+    for(size_t j = 0; j < n_threads; ++j)
+    {
+         boost::asio::post(pool_xor_to_additive, std::bind(xor_to_additive, party, target_share_read[j], std::ref(socketsPb[j]), std::ref(socketsP2[j])));
+    }
+
+    pool_xor_to_additive.join();
+    
+    auto end = std::chrono::steady_clock::now();
+    std::chrono::duration<double> elapsed_seconds = end-start;
+    std::cout << "time to generate and evaluate " << n_threads << " dpfs of size 2^" << atoi(argv[4]) << " is: " << elapsed_seconds.count() << "s\n";
+
+ for(size_t i = 0; i < n_threads; ++i)
+ {
+   write_evalfull_outs_into_a_file(party, i, db_nitems, flags[i],  leaves[i], final_correction_word[i]); 
+ }
+
+return 0;
 }

preprocessing/prg.h

@@ -1,10 +1,3 @@
-/* Copyright (C) 2019  Anonymous
- *
- * This is a pre-release version of the DPF++ library distributed anonymously
- * for peer review. A public release of the software will be published under the
- * LPGL v2.1 license in the near future. Please do not redistribute this version
- * of the software.
- */
 
 #ifndef DPFPP_PRG_H__
 #define DPFPP_PRG_H__

preprocessing/prg_aes_impl.h

@@ -1,10 +1,3 @@
-/* Copyright (C) 2019  Anonymous
- *
- * This is a pre-release version of the DPF++ library distributed anonymously
- * for peer review. A public release of the software will be published under the
- * LPGL v2.1 license in the near future. Please do not redistribute this version
- * of the software.
- */
 
 #ifndef DPFPP_PRG_AES_IMPL_H__
 #define DPFPP_PRG_AES_IMPL_H__

preprocessing/share-conversion.h

@@ -24,7 +24,6 @@ struct shareconversion
  */
 void convert_sharesP2(size_t db_nitems, __m128i** output0, int8_t ** flags0,  __m128i** output1, int8_t ** flags1, 
                     int64_t ** leaves0, int64_t ** leafbits0, int64_t ** leaves1, int64_t ** leafbits1,
-                    
                      std::vector<socket_t>& sockets0, std::vector<socket_t>& sockets1, size_t i, size_t socket_no = 0)
 { 
  du_attalah_P2(sockets0, sockets1, socket_no); 
@@ -74,9 +73,10 @@ void convert_sharesP2(size_t db_nitems, __m128i** output0, int8_t ** flags0,  __
             if(leafbit_reconstruction != 0) std::cout << std::dec << j << ":-> " << leafbit_reconstruction << std::endl;   
         }
     #endif
-      
-      P2_write_evalfull_outs_into_a_file(false, 0, db_nitems,  flags0[0], 	leaves0[0]);
-      P2_write_evalfull_outs_into_a_file(true,  0, db_nitems,  flags1[0], 	leaves1[0]);
+
+    
+      // P2_write_evalfull_outs_into_a_file(false, i, db_nitems,  flags0[i], 	leaves0[i]);
+      // P2_write_evalfull_outs_into_a_file(true,  i, db_nitems,  flags1[i], 	leaves1[i]);
 } 
 
 void  P2_xor_to_additive(tcp::socket& s0, tcp::socket& s1, size_t socket_no)
@@ -235,7 +235,7 @@ int64_t xor_to_additive(bool party, uint8_t * target_share_read, tcp::socket& sb
 
 void convert_shares(size_t i, __m128i ** output, int8_t ** flags, size_t n_threads, size_t db_nitems, __m128i * final_correction_word, 
 					int64_t ** leaves, int64_t ** leafbits,
-					tcp::socket& sb, tcp::socket& s2, bool party)
+				std::vector<socket_t>& socketsb, std::vector<socket_t>& sockets2, bool party)
 {
 	
 	#ifdef DEBUG
@@ -269,54 +269,45 @@ void convert_shares(size_t i, __m128i ** output, int8_t ** flags, size_t n_threa
 	}
 
  
-	int64_t FCWshare = du_attalah_Pb(final_correction_word[i][1], pm, s2, sb);
+	int64_t FCWshare = du_attalah_Pb(final_correction_word[i][1], pm, sockets2[i], socketsb[i]);
 
- 
-	
  FCWshare+=rb;
 	int64_t FCWshare_reconstruction;
- boost::asio::write(sb, boost::asio::buffer(&FCWshare, sizeof(FCWshare)));
-	boost::asio::read(sb, boost::asio::buffer(&FCWshare_reconstruction, sizeof(FCWshare_reconstruction)));
+ boost::asio::write(socketsb[i], boost::asio::buffer(&FCWshare, sizeof(FCWshare)));
+	boost::asio::read(socketsb[i], boost::asio::buffer(&FCWshare_reconstruction, sizeof(FCWshare_reconstruction)));
 	FCWshare_reconstruction = FCWshare_reconstruction + FCWshare;
 
- 
-	
 	int64_t PM = pm + rb;
 	int64_t PM_recv;
 
-	boost::asio::write(sb, boost::asio::buffer(&PM, sizeof(PM)));
-	boost::asio::read(sb, boost::asio::buffer(&PM_recv, sizeof(PM_recv)));
+	boost::asio::write(socketsb[i], boost::asio::buffer(&PM, sizeof(PM)));
+	boost::asio::read(socketsb[i], boost::asio::buffer(&PM_recv, sizeof(PM_recv)));
     
-    int64_t * flags_  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
+ int64_t * flags_  = (int64_t *)std::aligned_alloc(sizeof(node_t), db_nitems * sizeof(int64_t));
 
+ shareconversion P2_shareconversion;
+ P2_shareconversion.PM = pm;
+ P2_shareconversion.PM_recv = PM_recv;
+ P2_shareconversion.rb = rb;
+ P2_shareconversion.FCWshare_reconstruction = FCWshare_reconstruction;
 	
-
-
-    shareconversion P2_shareconversion;
-    P2_shareconversion.PM = pm;
-    P2_shareconversion.PM_recv = PM_recv;
-    P2_shareconversion.rb = rb;
-    P2_shareconversion.FCWshare_reconstruction = FCWshare_reconstruction;
-	
-    boost::asio::write(s2, boost::asio::buffer(&P2_shareconversion, sizeof(shareconversion)));
+ boost::asio::write(sockets2[i], boost::asio::buffer(&P2_shareconversion, sizeof(shareconversion)));
     
-    for(size_t j = 0; j < db_nitems; ++j)
+ for(size_t j = 0; j < db_nitems; ++j)
 	{
 		leaves[i][j]  = output[i][j][0];
 
- 
-
 		flags_[j] = (flags[i][j] * pm) + (flags[i][j] * PM_recv) + (flags[i][j] * rb); 
  
 		flags_[j] += output[i][j][1]; 
 
 		if(!party)
 		{	
-		    flags_[j] -= (flags[i][j] * FCWshare_reconstruction);		
+		 flags_[j] -= (flags[i][j] * FCWshare_reconstruction);		
 		}
 		if(party)
 		{ 
-		    flags_[j] -= (flags[i][j] * FCWshare_reconstruction);
+		 flags_[j] -= (flags[i][j] * FCWshare_reconstruction);
 		}
 	
 		#ifdef DEBUG
@@ -339,17 +330,22 @@ void convert_shares(size_t i, __m128i ** output, int8_t ** flags, size_t n_threa
 		
 		#ifdef DEBUG
             int8_t flags_rec2;
-            boost::asio::write(sb, boost::asio::buffer(&flags[i][j], sizeof(flags[i][j])));
-            boost::asio::read(sb, boost::asio::buffer(&flags_rec2, sizeof(flags_rec2)));
+            boost::asio::write(socketsb[i], boost::asio::buffer(&flags[i][j], sizeof(flags[i][j])));
+            boost::asio::read(socketsb[i], boost::asio::buffer(&flags_rec2, sizeof(flags_rec2)));
             flags_rec2 = flags_rec2 + flags[i][j];
 
+            int64_t flags_rec3;
+            boost::asio::write(socketsb[i], boost::asio::buffer(&flags_[j], sizeof(flags_[j])));
+            boost::asio::read(socketsb[i], boost::asio::buffer(&flags_rec3, sizeof(flags_rec3)));
+            flags_rec3 = flags_rec3 + flags_[j];
+
             if(flags_rec2 != 0)
             {
-                std::cout << j << " ---> Flag Reconstruction = " << (int) flags_rec2 << std::endl;
+                std::cout << j << " ---> Flag Reconstruction = " << (int) flags_rec2 << "----->>>>> " << flags_rec3 << std::endl;
                 if(flags_rec2 != 1) std::cout << (int) flags[i][j]  << "-> " << flags_[j] << std::endl;
             }
 		#endif
 	}
 
-	 write_evalfull_outs_into_a_file(party, i, db_nitems, flags,  leaves[0], final_correction_word); 
+	 // write_evalfull_outs_into_a_file(party, i, db_nitems, flags[i],  leaves[i], final_correction_word[i]); 
 }