diff --git a/Makefile b/Makefile
index 482541b..8b01e84 100644
--- a/Makefile
+++ b/Makefile
@@ -2,11 +2,25 @@ I2PD_PATH = i2pd
 LIBI2PD_PATH = $(I2PD_PATH)/libi2pd
 LIBI2PD_CLIENT_PATH = $(I2PD_PATH)/libi2pd_client
 CXX = g++
-FLAGS = -g -Wall -std=c++11 -Wno-misleading-indentation
+FLAGS = -Wall -std=c++11 -Wno-misleading-indentation
+
+ifneq ($(UNAME),Darwin && $(UNAME),Linux)
+	FLAGS += -Os -D_MT -DWIN32 -D_WINDOWS -DWIN32_LEAN_AND_MEAN
+	BOOST_SUFFIX = -mt
+else
+	FLAGS += -g
+endif
+
 INCFLAGS = -I$(LIBI2PD_PATH) -I$(LIBI2PD_CLIENT_PATH) -I$(I2PD_PATH)
-CXXFLAGS = $(FLAGS) $(INCFLAGS)
+CXXFLAGS = $(FLAGS)
 LDFLAGS = -Wl,-rpath,/usr/local/lib
-LIBS = $(I2PD_PATH)/libi2pd.a -lboost_system -lboost_date_time -lboost_filesystem -lboost_program_options -lssl -lcrypto -lpthread -lrt -lz
+LIBS = $(I2PD_PATH)/libi2pd.a -lboost_system$(BOOST_SUFFIX) -lboost_date_time$(BOOST_SUFFIX) -lboost_filesystem$(BOOST_SUFFIX) -lboost_program_options$(BOOST_SUFFIX) -lssl -lcrypto -lpthread -lz
+
+ifeq ($(UNAME),Darwin || $(UNAME),Linux)
+	LIBS += -lrt
+else
+	LIBS += -lws2_32 -lwsock32 -lstdc++ -liphlpapi
+endif
 
 SOURCES = $(wildcard *.cpp)
 OBJECTS = $(SOURCES:.cpp=.o)
@@ -42,7 +56,7 @@ $(I2PD_LIB):
 	$(MAKE) -C $(I2PD_PATH) mk_obj_dir $(I2PD_LIB)
 
 %.o: %.cpp libi2pd.a
-	$(CXX) -o $@ -c $(CXXFLAGS) $< $(INCFLAGS)
+	$(CXX) -o $@ -c $(CXXFLAGS) $(INCFLAGS) $<
 
 count:
 	wc *.c *.cc *.C *.cpp *.h *.hpp
diff --git a/vanity.hpp b/vanity.hpp
index 8fe7772..a60655c 100644
--- a/vanity.hpp
+++ b/vanity.hpp
@@ -5,22 +5,25 @@
 #include <openssl/rand.h>
 #include "Crypto.h"
 #include "Identity.h"
+#include "I2PEndian.h"
 #include "common/key.hpp"
 #include <thread>
 #include <unistd.h>
 #include <vector>
+
 #ifdef _WIN32
 #include <windows.h>
 #endif
+
 // sha256
-#define Ch(x, y, z)	((x & (y ^ z)) ^ z)
+#define Ch(x, y, z)		((x & (y ^ z)) ^ z)
 #define Maj(x, y, z)	((x & (y | z)) | (y & z))
-#define SHR(x, n)	(x >> n)
-#define ROTR(x, n)	((x >> n) | (x << (32 - n)))
-#define S0(x)		(ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
-#define S1(x)		(ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
-#define s0(x)		(ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))
-#define s1(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
+#define SHR(x, n)		(x >> n)
+#define ROTR(x, n)		((x >> n) | (x << (32 - n)))
+#define S0(x)			(ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
+#define S1(x)			(ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
+#define s0(x)			(ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3))
+#define s1(x)			(ROTR(x, 17) ^ ROTR(x, 19) ^ SHR(x, 10))
 
 #define RND(a, b, c, d, e, f, g, h, k) \
 	t0 = h + S1(e) + Ch(e, f, g) + k; \
diff --git a/vanitygen.cpp b/vanitygen.cpp
index 15e803f..d84153d 100644
--- a/vanitygen.cpp
+++ b/vanitygen.cpp
@@ -1,5 +1,4 @@
 #include "vanity.hpp"
-#define CPU_ONLY
 
 static void inline CalculateW (const uint8_t block[64], uint32_t W[64])
 {
@@ -7,11 +6,11 @@ static void inline CalculateW (const uint8_t block[64], uint32_t W[64])
 implementation of orignal
 */
 	for (int i = 0; i < 16; i++)
-		W[i] = be32toh (((uint32_t *)(block))[i]);
+		W[i] = htobe32(((uint32_t *)(block))[i]);
 	for (int i = 16; i < 64; i++)
 		W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
 }
- 
+
 static void inline TransformBlock (uint32_t state[8], const uint32_t W[64])
 {
 /*
@@ -37,8 +36,8 @@ implementation of orignal
 	RNDr(S, W, 52, 0x391c0cb3); RNDr(S, W, 53, 0x4ed8aa4a); RNDr(S, W, 54, 0x5b9cca4f); RNDr(S, W, 55, 0x682e6ff3);
 	RNDr(S, W, 56, 0x748f82ee); RNDr(S, W, 57, 0x78a5636f); RNDr(S, W, 58, 0x84c87814); RNDr(S, W, 59, 0x8cc70208);
 	RNDr(S, W, 60, 0x90befffa); RNDr(S, W, 61, 0xa4506ceb); RNDr(S, W, 62, 0xbef9a3f7); RNDr(S, W, 63, 0xc67178f2);
-	
-	for (int i = 0; i < 8; i++)	state[i] += S[i];		
+
+	for (int i = 0; i < 8; i++)	state[i] += S[i];
 }
 
 void inline HashNextBlock (uint32_t state[8], const uint8_t * block)
@@ -51,51 +50,41 @@ implementation of orignal
 	TransformBlock (state, W);
 }
 
-
-
-
-static bool check_prefix(const char * buf){
-unsigned short size_str=0;
-while(*buf)
+static bool check_prefix(const char * buf)
 {
- if(
- *buf < 48 
- || 
- (*buf > 57 && *buf < 65) 
- ||
- (*buf > 64 && *buf < 94) 
- || *buf > 125
- || size_str > 52
- )return false;
-size_str++;
-buf++;
-}
-return true;
+	unsigned short size_str=0;
+	while(*buf)
+	{
+		if(*buf < 48 || (*buf > 57 && *buf < 65) || (*buf > 64 && *buf < 94) || *buf > 125 || size_str > 52)
+			return false;
+		size_str++;
+		buf++;
+	}
+	return true;
 }
 
-
 static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char * outBuf, size_t outLen)
 {
 	size_t ret = 0, pos = 1;
 	int bits = 8, tmp = inBuf[0];
 	while (ret < outLen && (bits > 0 || pos < len))
-	{ 	
+	{
 		if (bits < 5)
 		{
 			if (pos < len)
 			{
 				tmp <<= 8;
-	      		tmp |= inBuf[pos] & 0xFF;
+				tmp |= inBuf[pos] & 0xFF;
 				pos++;
-	      		bits += 8;
+				bits += 8;
 			}
 			else // last byte
 			{
 				tmp <<= (5 - bits);
-			  	bits = 5;
+				bits = 5;
 			}
-		}	
-	
+		}
+
 		bits -= 5;
 		int ind = (tmp >> bits) & 0x1F;
 		outBuf[ret] = (ind < 26) ? (ind + 'a') : ((ind - 26) + '2');
@@ -105,15 +94,16 @@ static inline size_t ByteStreamToBase32 (const uint8_t * inBuf, size_t len, char
 	return ret;
 }
 
-static inline bool NotThat(const char * a, const char *b){
-while(*b)
- if(*a++!=*b++) return true;
-return false;
+static inline bool NotThat(const char * a, const char *b)
+{
+	while(*b)
+		if(*a++!=*b++)
+			return true;
+	return false;
 }
 
-
-#ifdef CPU_ONLY
-static inline bool thread_find(uint8_t * buf,const char * prefix,int id_thread,unsigned long long throughput){
+static inline bool thread_find(uint8_t * buf, const char * prefix, int id_thread, unsigned long long throughput)
+{
 /*
 Thanks to orignal ^-^
 For idea and example ^-^
@@ -125,82 +115,71 @@ Orignal is sensei of crypto ;)
 	{
 		uint8_t b[391];
 		uint32_t ll;
-	} local;	
+	} local;
 	union
 	{
 		uint8_t b[32];
 		uint32_t ll[8];
-	} hash; 
+	} hash;
 */
-	uint8_t * b = (uint8_t*)aligned_alloc(4,sizeof(uint8_t)*391);
-	uint32_t * hash = (uint32_t*)aligned_alloc(4,sizeof(uint32_t)*8);
+	uint8_t b[391];
+	uint32_t hash[8];
 
 	memcpy (b, buf, 391);
 
 	auto len = strlen (prefix);
 	// precalculate first 5 blocks (320 bytes)
-	uint32_t state[8] = 
-		{ 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 
-		  0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };
+	uint32_t state[8] = { 0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19 };
 	HashNextBlock (state, b);
 	HashNextBlock (state, b + 64);
 	HashNextBlock (state, b + 128);
 	HashNextBlock (state, b + 192);
-	HashNextBlock (state, b + 256);	
+	HashNextBlock (state, b + 256);
 
 	// pre-calculate last W
 	uint32_t lastW[64];
-	CalculateW (lastBlock, lastW); 
+	CalculateW (lastBlock, lastW);
 
 	uint32_t * nonce = (uint32_t *)(b+320);
-	(*nonce) += id_thread*throughput; 
-/*
+	(*nonce) += id_thread*throughput;
 
-*/
 	char addr[53];
 	uint32_t state1[8];
 
-while(throughput-- and !found){
-
-
-	memcpy (state1, state, 32);
-	// calculate hash of block with nonce	
-	HashNextBlock (state1, b + 320);
-	// apply last block	
-	TransformBlock (state1, lastW);		
-	// get final hash
-	for (int j = 8; j--;)
-		hash[j] = htobe32 (state1[j]);
-
-/*
-
-*/
-	ByteStreamToBase32 ((uint8_t*)hash, 32, addr, len);
-//	std::cout << addr << std::endl;
-	if(	!NotThat(addr,prefix)	){
-		ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
-		std::cout << "Address found " << addr << " in " << id_thread << std::endl;
-		found=true;
-		FoundNonce=*nonce;
-		free(hash);
-		free(b);
-		return true;
-	}
-
-	(*nonce)++;
-	hashescounter++;
-	if (found){
-	free(hash);
-	free(b);
-	break;	
-	}
+	while(throughput-- and !found)
+	{
+		memcpy (state1, state, 32);
+		// calculate hash of block with nonce
+		HashNextBlock (state1, b + 320);
+		// apply last block
+		TransformBlock (state1, lastW);
+		// get final hash
+		for (int j = 8; j--;)
+			hash[j] = htobe32(state1[j]);
+		ByteStreamToBase32 ((uint8_t*)hash, 32, addr, len);
+		//	std::cout << addr << std::endl;
+		if(!NotThat(addr,prefix))
+		{
+			ByteStreamToBase32 ((uint8_t*)hash, 32, addr, 52);
+			std::cout << "Address found " << addr << " in " << id_thread << std::endl;
+			found=true;
+			FoundNonce=*nonce;
+			free(hash);
+			free(b);
+			return true;
+		}
 
+		(*nonce)++;
+		hashescounter++;
+		if (found)
+		{
+			free(hash);
+			free(b);
+			break;
+		}
 	}//while
 }
 
-#endif
-
-
 int main (int argc, char * argv[])
 {
 	if ( argc < 3 )
@@ -208,126 +187,132 @@ int main (int argc, char * argv[])
 		std::cout << "Usage: " << argv[0] << " filename generatestring <threads(default of system)> <signature type>" << std::endl;
 		return 0;
 	}
-	if(!check_prefix(argv[2])){
+	if(!check_prefix(argv[2]))
+	{
 		std::cout << "Not correct prefix" << std::endl;
 		return 0;
 	}
 	i2p::crypto::InitCrypto (false);
 	type = i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519;
-	if ( argc > 3 ){
+	if ( argc > 3 )
+	{
 		unsigned int tmp = atoi(argv[3]);
-		if(tmp > 255) {
+		if(tmp > 255)
+		{
 			std::cout << "Really more than 255 threads?:D Nope, sorry" << std::endl;
 			return 0;
 		}
 		count_cpu=atoi(argv[3]);
-	}if ( argc > 4 ) {
+	}
+	if ( argc > 4 )
+	{
 		type = NameToSigType(std::string(argv[4]));
 	}
 
 ///////////////
 //For while
-if(type != i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519){
-	std::cout << "For a while only ED25519-SHA512" << std::endl;
-	return 0;
-}
+	if(type != i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519)
+	{
+		std::cout << "For a while only ED25519-SHA512" << std::endl;
+		return 0;
+	}
 ///////////////
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-			auto keys = i2p::data::PrivateKeys::CreateRandomKeys (type);
-			switch(type){
-			case i2p::data::SIGNING_KEY_TYPE_DSA_SHA1:
-			case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:	
-			case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
-			case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:		
-			case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
-			case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512:
-			case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512_TEST:
-			std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl;
-			return 0;			
-			break;							
-			}
-//TODO: for other types.
-			switch(type){
-			case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
-
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
-
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
-				
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
-
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
-
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
+	auto keys = i2p::data::PrivateKeys::CreateRandomKeys (type);
+	switch(type)
+	{
+		case i2p::data::SIGNING_KEY_TYPE_DSA_SHA1:
+		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
+		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
+		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
+		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
+		case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512:
+		case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_TC26_A_512_GOSTR3411_512_TEST:
+		std::cout << "Sorry, i don't can generate adress for this signature type" << std::endl;
+		return 0;
+		break;
+	}
 
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
+//TODO: for other types.
+	switch(type)
+	{
+		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA256_P256:
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA384_P384:
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_ECDSA_SHA512_P521:
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA256_2048:
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA384_3072:
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_RSA_SHA512_4096:
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_EDDSA_SHA512_ED25519:
 			MutateByte=320;
-			break;
-			case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_CRYPTO_PRO_A_GOSTR3411_256:
-			case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_CRYPTO_PRO_A_GOSTR3411_256_TEST:
-
-			break;
-			}
+		break;
+		case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_CRYPTO_PRO_A_GOSTR3411_256:
+		case i2p::data::SIGNING_KEY_TYPE_GOSTR3410_CRYPTO_PRO_A_GOSTR3411_256_TEST:
+		break;
+	}
 
+	KeyBuf = new uint8_t[keys.GetFullLen()];
+	keys.ToBuffer (KeyBuf, keys.GetFullLen ());
 
-  KeyBuf = new uint8_t[keys.GetFullLen()];
-  keys.ToBuffer (KeyBuf, keys.GetFullLen ());
-#ifdef __linux__
-  if(!count_cpu)
-   count_cpu = sysconf(_SC_NPROCESSORS_ONLN);
-#elif _WIN32
-  if(!count_cpu){
-	SYSTEM_INFO sysinfo;
-	GetSystemInfo(&sysinfo);
-	count_cpu = sysinfo.dwNumberOfProcessors;
-	}
+	if(!count_cpu)
+	{
+#if defined(WIN32)
+		SYSTEM_INFO siSysInfo;
+		GetSystemInfo(&siSysInfo);
+		count_cpu = siSysInfo.dwNumberOfProcessors;
+#elif defined(_SC_NPROCESSORS_CONF)
+		count_cpu = sysconf(_SC_NPROCESSORS_CONF);
+#elif defined(HW_NCPU)
+		int req[] = { CTL_HW, HW_NCPU };
+		size_t len = sizeof(count_cpu);
+		v = sysctl(req, 2, &count_cpu, &len, NULL, 0);
 #else
-  if(!count_cpu)
-  	 count_cpu = 4;
+		count_cpu = 4;
 #endif
-   std::cout << "Start vanity generator in " << count_cpu << " threads" << std::endl;
+	}
 
+	std::cout << "Start vanity generator in " << count_cpu << " threads" << std::endl;
 
-unsigned short attempts = 0;
-while(!found)
+	unsigned short attempts = 0;
+	while(!found)
+	{//while
+		{//stack(for destructors(vector/thread))
 
-{//while
-{//stack(for destructors(vector/thread))
+			std::vector<std::thread> threads(count_cpu);
+			unsigned long long thoughtput = 0x4F4B5A37;
 
-  std::vector<std::thread> threads(count_cpu);
-  unsigned long long thoughtput = 0x4F4B5A37;
+			for ( unsigned int j = count_cpu;j--;)
+			{
+				threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
+				thoughtput+=1000;
+			}//for
 
-  for ( unsigned int j = count_cpu;j--;){
-   threads[j] = std::thread(thread_find,KeyBuf,argv[2],j,thoughtput);
-   thoughtput+=1000;
-  }//for
+			for(unsigned int j = 0; j < count_cpu;j++)
+				threads[j].join();
 
-  for(unsigned int j = 0; j < count_cpu;j++)
-   threads[j].join();
-  
-  if(FoundNonce == 0){
-	RAND_bytes( KeyBuf+MutateByte , 90 );
-	std::cout << "Attempts #" << ++attempts << std::endl;
-   }
+			if(FoundNonce == 0)
+			{
+				RAND_bytes( KeyBuf+MutateByte , 90 );
+				std::cout << "Attempts #" << ++attempts << std::endl;
+			}
+
+		}//stack
+	}//while
 
-}//stack
-}//while
+	memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
+	std::cout << "Hashes: " << hashescounter << std::endl;
 
-  memcpy (KeyBuf + MutateByte, &FoundNonce, 4);
-  std::cout << "Hashes: " << hashescounter << std::endl;
-  
 	std::ofstream f (argv[1], std::ofstream::binary | std::ofstream::out);
 	if (f)
 	{
 		f.write ((char *)KeyBuf, keys.GetFullLen ());
-   		delete [] KeyBuf;
+		delete [] KeyBuf;
 	}
 	else
 		std::cout << "Can't create file " << argv[1] << std::endl;
@@ -336,4 +321,3 @@ while(!found)
 
 	return 0;
 }
-