diff --git a/importation-tool/ImportationTool.cpp b/importation-tool/ImportationTool.cpp
index 9713745..29f1db8 100644
--- a/importation-tool/ImportationTool.cpp
+++ b/importation-tool/ImportationTool.cpp
@@ -1,794 +1,794 @@
 #include <fstream> 
 #include <iostream>
 #include <stdlib.h>
 #include <stdio.h>
 #include <iomanip>
 #include <pqxx/pqxx> 
 #include "edu_harvard_i2b2_gen_util_CryptosystemBridge.cpp"
 
 #define MAX_ENTRY 10000
 
 using namespace std;
 using namespace pqxx;
 
 connection* connectDB(string);
 
 void disconnectDB(connection*);
 
 result* NON_TRANSACTIONstatement(connection*, string);
 
 void TRANSACTIONstatement(connection*, string);
 
 void skipLine(ifstream*);
 
 void readBlock(char*, ifstream*);
 
 void skipBlock(ifstream*, unsigned short);
 
 void writeKeySet(FV::sk_t*, FV::evk_t*, FV::pk_t*);
 
 void loadKeySet(ifstream*, FV::sk_t*, FV::evk_t*, FV::pk_t*);
 
 void writeLittleEndian(ofstream*, uint64_t);
 
 bool isLast(ifstream*);
 
 void printUsage(char*);
 
 void generateRandomAlphaNumeric(char*, int);
 
-void moreSpaceEncoding(uint64_t, int, unsigned int, ifstream*, streampos*, ofstream*, unsigned int, char*, FV::pk_t*);
+void moreSpaceEncoding(uint64_t, int, unsigned int, unsigned int, ifstream*, streampos*, ofstream*, unsigned int, char*, FV::pk_t*);
 
-void lessSpaceEncoding(uint64_t, int, unsigned int, ifstream*, streampos*, ofstream*, unsigned int, char*, FV::pk_t*);
+void lessSpaceEncoding(uint64_t, int, unsigned int, unsigned int, ifstream*, streampos*, ofstream*, unsigned int, char*, FV::pk_t*);
 
 void encrypt(FV::pk_t*, FV::params::poly_p*, ofstream*);
 
 int main(int argc, char* argv[]) {
 	if (argc < 2) {
 		printUsage(argv[0]);
 		return 1;
 	}
 
 	if (strcmp(argv[1], "-u") == 0) {
 		if (argc != 5) {
 			printUsage(argv[0]);
 			return 1;
 		}
 		ifstream ifs;
 		ofstream ofs;
 
 		srand (time(NULL));
 
 		ifs.open(argv[2]);
 
 		FV::params::poly_p sk;
 		FV::params::poly_p pk;
 
 		for (size_t i=0;i<POLY_DEGREE;i++) {
 			uint64_t v;
 			ifs.read((char*)&v, sizeof(uint64_t));
 			uint64_t r = rand();
 
 			r = (r << 32) | rand();
 			r %= v;
 
 			pk(0,i) = r;
 			sk(0,i) = v-r;
 		}
 		ifs.close();
 
 		//pk.invntt_pow_invphi();
 
 		char* id = (char*) malloc(51*sizeof(char));
 
 		generateRandomAlphaNumeric(id, 50);
 
 		ofs.open("proxy.sql");
 		ofs << "insert into gen_proxy_partial_key_mapping (partial_key_id, partial_key) values" << endl;
 		ofs << "(\'" << id << "\', E'\\\\x";
 
 		for (size_t i=0;i<POLY_DEGREE;i++) {
 			writeLittleEndian(&ofs, pk(0,i));
 		}
 
 		ofs << "');" << endl;;
 		ofs.close();
 
 		ofs.open("i2b2server.sql");
 		ofs << "insert into gen_partial_key_set (partial_key_id, partial_key) values" << endl;
 		ofs << "(\'" << id << "\', E'\\\\x";
 
 		for (size_t i=0;i<POLY_DEGREE;i++) {
 			writeLittleEndian(&ofs, sk(0,i));
 		}
 
 		ofs << "');" << endl;;
 
 		ofs << "insert into gen_user_mapping (user_id, access_level, partial_key_id) values" << endl;
 		ofs << "(\'" << argv[3] << "\', " << argv[4] << ", \'" << id << "\');" << endl;
 
 		ofs.close();
 
 		free(id);
 		cout << "DONE" << endl;
 		cout << "Please execute proxy.sql, i2b2server.sql on each server" << endl;
 		return 0;
 	} else if (strcmp(argv[1], "-f") == 0) {
 		connection* C = connectDB("dbname=i2b2importationtool user=i2b2importationtool password=i2b2importationtool \
     	hostaddr=127.0.0.1 port=5432");
 
 		bool clear_database=false;
 		bool new_encoding=false;
 
 		if(argc >=2 && strcmp(argv[2], "-d") == 0){
 			clear_database=true;
 			NON_TRANSACTIONstatement(C,"SELECT setval(\'public.patient_seq\',1)");
 			TRANSACTIONstatement(C,"DELETE FROM public.gen_variants;");
 		}else{
 			result* rs = NON_TRANSACTIONstatement(C,"SELECT nextval(\'public.patient_seq\')");
 			uint64_t aux = rs->front()[0].as<uint64_t>();
 			delete rs;
 			NON_TRANSACTIONstatement(C,"SELECT setval(\'public.patient_seq\',"+to_string(aux-1)+")");
 		}
 
 		if( (argc >2 && strcmp(argv[2], "-i") == 0) || (argc >3 && strcmp(argv[3], "-i") == 0) ){
 			new_encoding=true;
 		}
 
 		ifstream ifs, keyset;
 		ofstream ofs, res, aggregate;
 
 		FV::sk_t* secret_key = new FV::sk_t();
 		FV::evk_t* evaluation_key = new FV::evk_t(*secret_key, 32);
 		FV::pk_t* public_key = new FV::pk_t(*secret_key, *evaluation_key);
 
 	  	// Write key set
 	  	if ((argc == 3 && clear_database == false && new_encoding == false) || (argc == 4 && clear_database == true && new_encoding == false) || 
 	  		(argc == 4 && clear_database == false && new_encoding == true) || (argc == 5 && clear_database == true && new_encoding == true)) {
 	  		cout << "Generate new keyset" << endl;
 			writeKeySet(secret_key, evaluation_key, public_key);
 			
 			ifs.open(argv[argc-1]);
 		} else if ((argc == 4 && clear_database == false && new_encoding == false) || (argc == 5 && clear_database == true && new_encoding == false) || 
 			(argc == 5 && clear_database == false && new_encoding == true) || (argc == 6 && clear_database == true && new_encoding == true)) {
 			// Load exist key
 			cout << "Load existing keyset" << endl;
 			keyset.open(argv[argc-1]);
 			loadKeySet(&keyset, secret_key, evaluation_key, public_key);
 			keyset.close();
 			
 			ifs.open(argv[argc-2]);
 		} else {
 			printUsage(argv[0]);
 			return 1;
 		}
 
 		// skip header
 		char c;
 		do {
 			skipLine(&ifs);
 			ifs.seekg(1, ifs.cur);
 			ifs.get(c);
 		} while (c == '#');
 		
 		// Get individuals number
 		// skip column definition, 9 columns #CHROM, POS, ID, REF, ALT, QUAL, FILTER, INFO, FORMAT are metadata
 		// need to parse patient identifier
 		int count=-9;
 		do {
 			skipBlock(&ifs, 1);
 			count++;
 			ifs.get(c);
 		} while (c != '\n');
 
 		if (count <= 0) {
 			cout << "No one is in given files" << endl;
 			return 1;
 		}
 
 		cout << count << " individual(s) are found" << endl;
 
 		result* rs = NON_TRANSACTIONstatement(C,"SELECT currval(\'public.patient_seq\')");
 		uint64_t patients_log = rs->front()[0].as<uint64_t>();
 		delete rs;
 
 		ofs.open("individuals.sql");
 		ofs << "insert into gen_patient_mapping(pid_gen) values" << endl;
 		for (int i=0;i<count;i++) {
 			ofs << "(" << (patients_log+i) << ")," << endl;
 			NON_TRANSACTIONstatement(C,"SELECT nextval(\'public.patient_seq\')");
 		}
 
 		ofs.seekp(-2, ofs.end);
 		ofs << ';';
 		ofs.close();
 
 		streampos* pos = (streampos*) malloc(POLY_DEGREE*sizeof(streampos));
 		
 		vector<char*> container;
 		for(int param=0; param<5; param++){
 			char* buffer = (char*) malloc(1024*sizeof(char));
 			container.push_back(buffer);
 		}
 		char* buffer = (char*) malloc(1024*sizeof(char));
 
 		unsigned int cipherid;
 		unsigned int degree;
 		if(clear_database==true){
 			cipherid=0;
 			degree=0;
 		}else{
 			result* rs = NON_TRANSACTIONstatement(C,"SELECT cipher_id, degree FROM public.gen_variants ORDER BY cipher_id, degree DESC LIMIT 1;");
 			
 			if(rs->size()>0){
 				cipherid = rs->front()[0].as<unsigned int>();
 				degree = rs->front()[1].as<unsigned int>();
 
 				if(degree<POLY_DEGREE - 1){
 					degree++;
 				}else{
 					cipherid++;
 					degree=0;
 				}
 			}else{
 				cipherid=0;
 				degree=0;
 			}
 		}
 
 		unsigned int n = POLY_DEGREE;
 		bool hasNext = true;
 		long variants = 0;
 		int fileId = 0;
 		int NbEntries = 0;
 		bool new_variants = false;
 
 		ofs.open("variants.sql");
 		ofs << "delete from gen_noisy_result;" << endl;
 		ofs << "insert into gen_variants (cipher_id, degree, chromosome, position, rs_number, reference, alternate) values" << endl;
 		aggregate.open("genotypes.sql");
 		aggregate << "\\i genotypes-0.sql" << endl;
 		res.open("genotypes-0.sql");
 		if(new_encoding == false){
 			res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, no_calls) values" << endl;	
 		}else{
 			res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, cipher_gt3, cipher_gt4, cipher_gt5) values" << endl;	
 		}
 
 		while (hasNext) {
 			if (NbEntries >= MAX_ENTRY) {
 				res.seekp(-2, res.end);
 				res << ';';
 				res.close();
 				
 				fileId++;
 				NbEntries = 0;
 
 				aggregate << "\\i genotypes-" << to_string(fileId) << ".sql" << endl;
 				res.open("genotypes-" + to_string(fileId) + ".sql");
 
 				if(new_encoding == false){
 					res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, no_calls) values" << endl;	
 				}else{
 					res << "insert into gen_encrypted_genotypes (cipher_id, pid_gen, cipher_gt1, cipher_gt2, cipher_gt3, cipher_gt4, cipher_gt5) values" << endl;	
 				}
 				
 			}
 
 			// parse variant information
 			for (size_t i=degree;i<n;i++) {
 				// read variant information
 				readBlock(container[0], &ifs); // chromosome
 				readBlock(container[1], &ifs); // position
 				readBlock(container[2], &ifs); // rs_number
 				readBlock(container[3], &ifs); // reference
 				readBlock(container[4], &ifs); // alternate
 
 				string select_query="",insert_query="";
 				if (*container[2] == '.') {
 					select_query="SELECT COUNT(*) FROM public.gen_variants WHERE chromosome=\'"+string(container[0])+"\' AND \"position\"="+string(container[1])+" AND rs_number=\'"+string(container[2])+"\' and reference=\'"+string(container[3])+"\' AND alternate=\'"+string(container[4])+"\';";
 					insert_query="INSERT INTO public.gen_variants (cipher_id, degree, chromosome, position, rs_number, reference, alternate) VALUES ("+to_string(cipherid)+","+to_string(i)+",\'"+string(container[0])+"\',"+string(container[1])+",\'"+string(container[2])+"\',\'"+string(container[3])+"\',\'"+string(container[4])+"\');";
 				}else{
 					select_query="SELECT COUNT(*) FROM public.gen_variants WHERE chromosome=\'"+string(container[0])+"\' AND \"position\"="+string(container[1])+" AND rs_number=\'"+string(container[2])+"\' AND reference=\'"+string(container[3])+"\' AND alternate=\'"+string(container[4])+"\';";
 					insert_query="INSERT INTO public.gen_variants (cipher_id, degree, chromosome, position, rs_number, reference, alternate) VALUES ("+to_string(cipherid)+","+to_string(i)+",\'"+string(container[0])+"\',"+string(container[1])+",\'"+string(container[2])+"\',\'"+string(container[3])+"\',\'"+string(container[4])+"\');";
 				}
 				
 				// check if variant exists
 				result* rs = NON_TRANSACTIONstatement(C,select_query);
 				bool exists = rs->front()[0].as<bool>();
 				delete rs;
 
 				if(exists == false){
 					new_variants = true;
 					TRANSACTIONstatement(C,insert_query);
 				
 					// if variant does not yet exist write to file
 					ofs << '(' << cipherid << ", " << i << ", \'"; // cipher_id
 					ofs << container[0] << "\', "; // chromosome
 					ofs << container[1] << ", ";   // position
 				
 					// rs_number
 					if (*container[2] == '.') {
 						ofs << "null";
 					} else {
 						ofs << '\'' << container[2] << '\'';
 					}
 					ofs << ", \'";
 
 					ofs << container[3] << "\', \'"; // reference
 					ofs << container[4] << "\'),"; // alternate
 
 					ofs << endl;
 				}
 
 				skipBlock(&ifs, 4);
 				*(pos+i-degree) = ifs.tellg();
 				skipLine(&ifs);
 
 				if (isLast(&ifs)) {
 					n=i+1-degree;
 					hasNext = false;
 					ifs.clear();
 				}
 
 				degree = 0;
 			}
 
 			if(new_encoding==false){
 				lessSpaceEncoding(patients_log,count,degree,n,&ifs,pos,&res,cipherid,buffer,public_key);
 				NbEntries += 2*count;
 			}else{
 				moreSpaceEncoding(patients_log,count,degree,n,&ifs,pos,&res,cipherid,buffer,public_key);
 				NbEntries += 5*count;
 			}
 
 			skipLine(&ifs);
 			cipherid++;
 			variants += n;
 			cout << variants << " variants are processed" << endl;
 		}
 
 		// replace , of last column to ;
 		ofs.seekp(-2, ofs.end);
 		ofs << ';';
 
 		res.seekp(-2, res.end);
 		res << ';';
 
 		ifs.close();
 		ofs.close();
 		if(new_variants == false){
 			ofs.open("variants.sql");
 			ofs.close();
 		}
 		res.close();
 		aggregate.close();
 		for(size_t i=0;i<container.size();i++){
 			free(container[i]);
 		}
 		free(buffer);
 		free(pos);
 		delete secret_key;
 		delete evaluation_key;
 		delete public_key;
 		disconnectDB(C);
 
 		cout << "DONE" << endl;
 		cout << "Please execute individuals.sql, variants.sql, genotypes.sql";
 		if (argc == 3)
 			cout << ", parameters.sql";
 		cout << " to load data" << endl;
 		return 0;
 	} else {
 		printUsage(argv[0]);
 		return 1;
 	}
 }
 
-void moreSpaceEncoding(uint64_t patients_log, int count, unsigned int degree, unsigned n, ifstream* ifs, streampos* pos, ofstream* res, unsigned int cipherid, char* buffer, FV::pk_t* public_key){
+void moreSpaceEncoding(uint64_t patients_log, int count, unsigned int degree, unsigned int n, ifstream* ifs, streampos* pos, ofstream* res, unsigned int cipherid, char* buffer, FV::pk_t* public_key){
 	for (uint64_t i=patients_log; i<patients_log+count; i++) {
 		// for each individual
 		FV::params::poly_p gt1;
 		FV::params::poly_p gt2;
 		FV::params::poly_p gt3;
 		FV::params::poly_p gt4;
 		FV::params::poly_p gt5;
 
 		for (size_t j=0;j<degree;j++) {
 			gt1(0,j) = (uint64_t)0;
 			gt2(0,j) = (uint64_t)0;
 			gt3(0,j) = (uint64_t)0;
 			gt4(0,j) = (uint64_t)0;
 			gt5(0,j) = (uint64_t)0;
 		}
 
 		for (size_t j=degree;j<n;j++) {
 			ifs->seekg(*(pos+j-degree));
 			readBlock(buffer,ifs);
 			*(pos+j-degree) = ifs->tellg();
 
 			if (*buffer == '0') {
 				if (*(buffer+2) == '0') {
 					gt1(0,j) = (uint64_t)1;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)0;
 					gt5(0,j) = (uint64_t)2;
 				} else if (*(buffer+2) == '.') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)0;
 					gt5(0,j) = (uint64_t)1;
 				} else {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)1;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)1;
 					gt5(0,j) = (uint64_t)2;
 				}
 			} else if (*buffer == '.') {
 				if (*(buffer+2) == '0') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)0;
 					gt5(0,j) = (uint64_t)1;
 				} else if (*(buffer+2) == '.') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)0;
 					gt5(0,j) = (uint64_t)0;
 				} else {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)1;
 					gt5(0,j) = (uint64_t)1;
 				}
 			} else {
 				if (*(buffer+2) == '0') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)1;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)1;
 					gt5(0,j) = (uint64_t)2;
 				} else if (*(buffer+2) == '.') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)0;
 					gt4(0,j) = (uint64_t)1;
 					gt5(0,j) = (uint64_t)1;
 				} else {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					gt3(0,j) = (uint64_t)1;
 					gt4(0,j) = (uint64_t)2;
 					gt5(0,j) = (uint64_t)2;
 				}
 			}
 			
 		}
 		*res << '(' << dec << cipherid << ',' << i;
 
 		encrypt(public_key,&gt1,res);
 		encrypt(public_key,&gt2,res);
 		encrypt(public_key,&gt3,res);
 		encrypt(public_key,&gt4,res);
 		encrypt(public_key,&gt5,res);
 
 		*res << ")," << endl;
 	}	
 }
 
 
-void lessSpaceEncoding(uint64_t patients_log, int count, unsigned int degree, unsigned n, ifstream* ifs, streampos* pos, ofstream* res, unsigned int cipherid, char* buffer, FV::pk_t* public_key){
+void lessSpaceEncoding(uint64_t patients_log, int count, unsigned int degree, unsigned int n, ifstream* ifs, streampos* pos, ofstream* res, unsigned int cipherid, char* buffer, FV::pk_t* public_key){
 	for (uint64_t i=patients_log; i<patients_log+count; i++) {
 		// for each individual
 		FV::params::poly_p gt1;
 		FV::params::poly_p gt2;
 		unsigned char* noc = (unsigned char*) malloc(POLY_DEGREE/4*sizeof(char));
 
 		for (size_t j=0;j<degree;j++) {
 			if (j%4 == 0) {
 				*(noc+j/4)=0;
 			}
 			
 			*(noc+j/4) |= 0x02 << 2*(j%4);
 		}
 
 		for (size_t j=degree;j<n;j++) {
 			ifs->seekg(*(pos+j-degree));
 			readBlock(buffer,ifs);
 			*(pos+j-degree) = ifs->tellg();
 
 			if (j%4 == 0) {
 				*(noc+j/4)=0;
 			}
 
 			if (*buffer == '0') {
 				if (*(buffer+2) == '0') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 				} else if (*(buffer+2) == '.') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)1;
 					*(noc+j/4) |= 0x01 << 2*(j%4);
 				} else {
 					gt1(0,j) = (uint64_t)1;
 					gt2(0,j) = (uint64_t)0;
 				}
 			} else if (*buffer == '.') {
 				if (*(buffer+2) == '0') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)1;
 					*(noc+j/4) |= 0x01 << 2*(j%4);
 				} else if (*(buffer+2) == '.') {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)0;
 					*(noc+j/4) |= 0x02 << 2*(j%4);
 				} else {
 					gt1(0,j) = (uint64_t)1;
 					gt2(0,j) = (uint64_t)0;
 					*(noc+j/4) |= 0x01 << 2*(j%4);
 				}
 			} else {
 				if (*(buffer+2) == '0') {
 					gt1(0,j) = (uint64_t)1;
 					gt2(0,j) = (uint64_t)0;
 				} else if (*(buffer+2) == '.') {
 					gt1(0,j) = (uint64_t)1;
 					gt2(0,j) = (uint64_t)0;
 					*(noc+j/4) |= 0x01 << 2*(j%4);
 				} else {
 					gt1(0,j) = (uint64_t)0;
 					gt2(0,j) = (uint64_t)1;
 				}
 			}
 			
 		}
 		for (size_t j=n;j<POLY_DEGREE;j++) {
 			if (j%4 == 0) {
 				*(noc+j/4)=0;
 			}
 
 			*(noc+j/4) |= 0x02 << 2*(j%4);
 		}
 		*res << '(' << dec << cipherid << ',' << i;
 
 		encrypt(public_key,&gt1,res);
 		encrypt(public_key,&gt2,res);
 
 		*res << ", E'\\\\x";
 		for (size_t k=0;k<POLY_DEGREE/4;k++)
 			*res << setfill('0') << setw(2) << hex << (int)*(noc+k);
 
 		*res << "')," << endl;
 		
 		free(noc);
 	}	
 }
 
 void encrypt(FV::pk_t* public_key, FV::params::poly_p* gt, ofstream* res){
 	*res << ", E'\\\\x";
 	FV::ciphertext_t* cipher = new FV::ciphertext_t();
 	encrypt_poly(*cipher, *public_key, *gt);
 
 	for (size_t k=0;k<POLY_DEGREE;k++) {
 		writeLittleEndian(res, (cipher->c0)(0,k));
 	}
 	for (size_t k=0;k<POLY_DEGREE;k++) {
 		writeLittleEndian(res, (cipher->c1)(0,k));
 	}
 	*res << "'";
 	delete cipher;
 }
 
 connection* connectDB(string dbname){ 
 	try{
       connection* C = new connection(dbname);
       if (C->is_open()) {
          cout << "Opened database successfully: " << C->dbname() << endl;
       } else {
          cout << "Can't open database" << endl;
          exit(1);
       }
       return C;
    }catch (const std::exception &e){
       cerr << e.what() << std::endl;
       exit(1);
    }
    
 }
 
 void disconnectDB(connection* C){
 	try{
       C->disconnect ();
       cout << "Closed database successfully." << endl;
    }catch (const std::exception &e){
       cerr << e.what() << std::endl;
       exit(1);
    }
 }
 
 result* NON_TRANSACTIONstatement(connection* C, string statement){
 
 	try{
 		/* Create SQL statement */
 		string sql = statement;
 
 		/* Create a non-transactional object. */
 		nontransaction N(*C);
 
 		/* Execute SQL query */
 		result* R = new result(N.exec(sql));
 		return R;
 	}catch (const std::exception &e){
     	cerr << e.what() << std::endl;
     	exit(1);
    	}
 }
 
 void TRANSACTIONstatement(connection* C, string statement){
 	
 	try{
 		/* Create SQL statement */
 		string sql = statement;
 
 		/* Create a transactional object. */
       	work W(*C);
       
       	/* Execute SQL query */
       	W.exec(sql);
       	W.commit();
 	}catch (const std::exception &e){
     	cerr << e.what() << std::endl;
     	exit(1);
    	}
 }
 
 void skipLine(ifstream* ifs) {
 	char c;
 	
 	do {
 		ifs->get(c);
 	} while (c != '\n');
 }
 
 void readBlock(char* block, ifstream* ifs) {
 	char c;
 
 	do {
 		ifs->get(c);
 	} while (c == ' ' || c == '\t');
 
 	do {
 		*block = toupper(c);
 		ifs->get(c);
 		block++;
 	} while (c != ' ' && c != '\t' && c != '\n');
 	ifs->seekg(-1, ifs->cur);
 	*block = '\0';
 }
 
 void skipBlock(ifstream* ifs, unsigned short n) {
 	char c;
 
 	for (size_t i=0;i<n;i++){
 		do {
 			ifs->get(c);
 		} while (c == ' ' || c == '\t');
 
 		do {
 			ifs->get(c);
 		} while (c != ' ' && c != '\t' && c != '\n');
 	}
 	ifs->seekg(-1, ifs->cur);
 }
 
 void writeKeySet(FV::sk_t* sk, FV::evk_t* evk, FV::pk_t* pk) {
 	ofstream ofs;
 	ofs.open("keyset");
 
   	// write secret key
   	for (size_t i=0;i<POLY_DEGREE;i++) {
 		ofs.write((char*)&(sk->value)(0,i), sizeof(uint64_t));
 	}
 	
 	// write public key
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		ofs.write((char*)&(pk->a)(0,i), sizeof(uint64_t));
 	}
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		ofs.write((char*)&(pk->b)(0,i), sizeof(uint64_t));
 	}
 	
 	// write evaluation key
 	for (size_t i=0; i<evk->ell; i++) {
 		for (size_t j=0; j<POLY_DEGREE; j++) {
 			ofs.write((char*)&(*(*evk->values+i))(0,j), sizeof(uint64_t));
 		}
 	}
 
 	ofs.close();
 
 	ofs.open("parameters.sql");
 	ofs << "insert into gen_parameters (poly_degree, nb_moduli, public_key, evaluation_key, plaintext_modulus) values" << endl;
 
 	ofs << '(' << std::dec << POLY_DEGREE << ", " << FV::params::poly_p::nmoduli << ", E'\\\\x";
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		writeLittleEndian(&ofs, (pk->a)(0,i));
 	}
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		writeLittleEndian(&ofs, (pk->b)(0,i));
 	}
 	ofs << "', E'\\\\x";
 	for (size_t i=0; i<evk->ell; i++) {
 		for (size_t j=0; j<POLY_DEGREE; j++) {
 			writeLittleEndian(&ofs, (*(*evk->values+i))(0,j));
 		}
 	}
 	ofs << "', " << std::dec << FV::params::plaintextModulus<mpz_class>::value() << ");" << endl;
 	ofs.close();
 }
 
 void loadKeySet(ifstream* ifs, FV::sk_t* sk, FV::evk_t* evk, FV::pk_t* pk) {
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		ifs->read((char*)&(sk->value)(0,i), sizeof(uint64_t));
 	}
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		ifs->read((char*)&(pk->a)(0,i), sizeof(uint64_t));
 	}
 	for (size_t i=0;i<POLY_DEGREE;i++) {
 		ifs->read((char*)&(pk->b)(0,i), sizeof(uint64_t));
 	}
 	for (size_t i=0; i<evk->ell; i++) {
 		for (size_t j=0; j<POLY_DEGREE; j++) {
 			ifs->read((char*)&(*(*evk->values+i))(0,j), sizeof(uint64_t));
 		}
 	}
 
 	pk->a_shoup = nfl::compute_shoup(pk->a);
 	pk->b_shoup = nfl::compute_shoup(pk->b);
 }
 
 void writeLittleEndian(ofstream* ofs, uint64_t v) {
 	*ofs << setfill('0') << setw(2) << hex << (int) (v&0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 8) & 0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 16) & 0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 24) & 0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 32) & 0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 40) & 0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 48) & 0xFF);
   	*ofs << setfill('0') << setw(2) << (int) ((v >> 56) & 0xFF);
 }
 
 bool isLast(ifstream* ifs) {
 	ifs->get();
 	if (ifs->eof())
 		return true;
 
 	ifs->seekg(-1, ifs->cur);
 	return false;
 }
 
 void printUsage(char* filename) {
 	cerr << "Usage : " << filename << " -f [-d] [-i] VCF_FILE KEYSET_FILE" << endl;
 	cerr << "        Generate SQL insertion query files from VCF file" << endl;
 	cerr << "Usage : " << filename << " -f [-d] [-i] VCF_FILE" << endl;
 	cerr << "        Generate SQL insertion query files from VCF file" << endl;
 	cerr << "        New keyset and encryption parameters will be generated" << endl;
 	cerr << "Usage : " << filename << " -u KEYSET_FILE USER_NAME ACCESS_LEVEL" << endl;
 	cerr << "        Create new user, USER_NAME must be username of i2b2" << endl;
 }
 
 void generateRandomAlphaNumeric(char* target, int length) {
 	const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789~!@#$^*()_+{}[]";
 
 	for (int i=0;i<length;i++) {
 		target[i] = charset[rand()%(sizeof(charset)-1)];
 	}
 	
 	target[length] = '\0';
 }