diff --git a/src/string.c b/src/string.c
index 8a93b52..026acb2 100644
--- a/src/string.c
+++ b/src/string.c
@@ -522,52 +522,59 @@
 }
 
 
+
 //memory functions
-void* memcpy(void *dest, const void *src, size_t num)
+void* memcpy(void* dest, const void* src, size_t num)
 {
+#define BLOCK_SIZE (sizeof(long) << 2)
+
 	if (num)
 	{
-		const uint8_t *src_ptr8 = (const uint8_t*)src;
-		uint8_t *dest_ptr8 = (uint8_t*)dest;	
-		uint8_t * const dest_ptr8_end = dest_ptr8 + num;
-		
-		if (((uintptr_t)src_ptr8 & 0x03) == ((uintptr_t)dest_ptr8 & 0x03))		//if we have the same alignment
-		{
-			uint8_t *end = (uint8_t*)(((uintptr_t)dest_ptr8 + 3) & ~0x3);
-			if (end > dest_ptr8_end)
-				end = dest_ptr8_end;
-		
-			while(dest_ptr8 < end)
-				*dest_ptr8++ = *src_ptr8++;
-		
-			uint32_t *dest_ptr32 = (uint32_t*)dest_ptr8;
-			const uint32_t *src_ptr32 = (const uint32_t*)src_ptr8;
-			uint32_t * const dest_ptr32_end = (uint32_t*)((uintptr_t)dest_ptr8_end & ~0x3);
-			while(dest_ptr32 < dest_ptr32_end)
-				*dest_ptr32++ = *src_ptr32++;
+		const uint8_t* sptr = (const uint8_t*)src;
+		uint8_t* dptr = (uint8_t*)dest;	
 
-			dest_ptr8 = (uint8_t*)dest_ptr32;
-			src_ptr8 = (uint8_t*)src_ptr32;
-			while(dest_ptr8 < dest_ptr8_end)
-				*dest_ptr8++ = *src_ptr8++;
-		}
-		else
+		if ((num >= BLOCK_SIZE) &&
+			(((uintptr_t)sptr & (sizeof(long) - 1)) == 0) &&
+			(((uintptr_t)dptr & (sizeof(long) - 1)) == 0))
 		{
-			while(dest_ptr8 < dest_ptr8_end)
-				*dest_ptr8++ = *src_ptr8++;
+			const long* sptr_aligned = (const long*)sptr;
+			long* dptr_aligned = (long*)dptr;
+
+			while(num >= BLOCK_SIZE)
+			{
+				*dptr_aligned++ = *sptr_aligned++;
+				*dptr_aligned++ = *sptr_aligned++;
+				*dptr_aligned++ = *sptr_aligned++;
+				*dptr_aligned++ = *sptr_aligned++;
+
+				num -= BLOCK_SIZE;
+			}
+
+			while(num >= sizeof(long))
+			{
+				*dptr_aligned++ = *sptr_aligned++;
+				num -= sizeof(long);
+			}
+
+
+			sptr = (const uint8_t*)sptr_aligned;
+			dptr = (uint8_t*)dptr_aligned;	
 		}
+		
+		while(num--)
+			*dptr++ = *sptr++;
 	}
 
 	return dest;
 }
 
-void* memmove(void *dest, const void *src, size_t num)
+void* memmove(void* dest, const void* src, size_t num)
 {
 	if (dest == src)
 		return dest;
 		
-	uint8_t *src_p8 = (uint8_t*)src;
-	uint8_t *dest_p8 = (uint8_t*)dest;
+	const uint8_t* src_p8 = (const uint8_t*)src;
+	uint8_t* dest_p8 = (uint8_t*)dest;
 		
 	if (src < dest)
 	{
@@ -592,10 +599,10 @@
 //const void* memchr(const void *ptr, uint8_t value, size_t num);
 //void* memchr(void *ptr, uint8_t value, size_t num);
 
-int memcmp(const void *ptr1, const void *ptr2, size_t num)
+int memcmp(const void* ptr1, const void* ptr2, size_t num)
 {
-	const uint8_t *l_ptr8 = (const uint8_t*)ptr1;
-	const uint8_t *r_ptr8 = (const uint8_t*)ptr2;
+	const uint8_t* l_ptr8 = (const uint8_t*)ptr1;
+	const uint8_t* r_ptr8 = (const uint8_t*)ptr2;
 
 	while(num--)
 	{
@@ -612,28 +619,41 @@
 }
 
 
-void* memset(void *ptr, uint8_t value, size_t num)
+void* memset(void* ptr, uint8_t value, size_t num)
 {
+#define BLOCK_SIZE (sizeof(long) << 2)
+
 	if (num)
 	{
-		uint8_t *dest_ptr8 = (uint8_t*)ptr;	
-		uint8_t * const dest_ptr8_end = dest_ptr8 + num;
-		const uint32_t value32 = ((uint32_t)value << 24) + ((uint32_t)value << 16) + ((uint32_t)value << 8) + (uint32_t)value;
-		
-		uint8_t *end = (uint8_t*)(((uintptr_t)dest_ptr8 + 3) & ~0x3);
-		if (end > dest_ptr8_end)
-			end = dest_ptr8_end;
-		while(dest_ptr8 < end)
-			*dest_ptr8++ = value;
-	
-		uint32_t *dest_ptr32 = (uint32_t*)dest_ptr8;
-		uint32_t * const dest_ptr32_end = (uint32_t*)((uintptr_t)dest_ptr8_end & ~0x3);
-		while(dest_ptr32 < dest_ptr32_end)
-			*dest_ptr32++ = value32;
+		uint8_t* dptr = (uint8_t*)ptr;	
 
-		dest_ptr8 = (uint8_t*)dest_ptr32;
-		while(dest_ptr8 < dest_ptr8_end)
-			*dest_ptr8++ = value;
+		if ((num >= BLOCK_SIZE) &&
+			(((uintptr_t)dptr & (sizeof(long) - 1)) == 0))
+		{
+			const uint32_t value32 = ((uint32_t)value << 24) + ((uint32_t)value << 16) + ((uint32_t)value << 8) + (uint32_t)value;
+			long* dptr_aligned = (long*)dptr;
+
+			while(num >= BLOCK_SIZE)
+			{
+				*dptr_aligned++ = value32;
+				*dptr_aligned++ = value32;
+				*dptr_aligned++ = value32;
+				*dptr_aligned++ = value32;
+
+				num -= BLOCK_SIZE;
+			}
+
+			while(num >= sizeof(long))
+			{
+				*dptr_aligned++ = value32;
+				num -= sizeof(long);
+			}
+
+			dptr = (uint8_t*)dptr_aligned;	
+		}
+		
+		while(num--)
+			*dptr++ = value;
 	}
 	
 	return ptr;