diff --git a/samples/Makefile b/samples/Makefile
index 1ebb891f..72d1ca45 100644
--- a/samples/Makefile
+++ b/samples/Makefile
@@ -97,6 +97,8 @@ endif
 ifneq (,$(findstring x86,$(UNICORN_ARCHS)))
 SOURCES += sample_x86.c
 SOURCES += shellcode.c
+SOURCES += mem_unmap.c
+SOURCES += mem_protect.c
 endif
 ifneq (,$(findstring m68k,$(UNICORN_ARCHS)))
 SOURCES += sample_m68k.c
@@ -111,7 +113,7 @@ all: $(BINARY)
 clean:
 	rm -rf *.o $(OBJS_ELF) $(BINARY) $(SAMPLEDIR)/*.exe $(SAMPLEDIR)/*.static $(OBJDIR)/lib$(LIBNAME)* $(OBJDIR)/$(LIBNAME)*
 	rm -rf libunicorn*.so libunicorn*.lib libunicorn*.dylib unicorn*.dll unicorn*.lib
-	rm -rf sample_x86 sample_arm sample_arm64 sample_mips sample_sparc sample_ppc sample_m68k shellcode
+	rm -rf sample_x86 sample_arm sample_arm64 sample_mips sample_sparc sample_ppc sample_m68k shellcode mem_unmap mem_protect
 
 $(BINARY): $(OBJS)
 
diff --git a/samples/mem_protect.c b/samples/mem_protect.c
new file mode 100755
index 00000000..4afb88c1
--- /dev/null
+++ b/samples/mem_protect.c
@@ -0,0 +1,323 @@
+/*
+
+uc_mem_protect demo / unit test
+
+Copyright(c) 2015 Chris Eagle
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 2 as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+*/
+
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <unicorn/unicorn.h>
+
+unsigned char PROGRAM[] =
+   "\xc7\x05\x00\x00\x20\x00\x41\x41\x41\x41\x90\xc7\x05\x00\x00\x20"
+   "\x00\x42\x42\x42\x42\xc7\x05\x00\x00\x30\x00\x43\x43\x43\x43\x90"
+   "\xc7\x05\x00\x00\x30\x00\x44\x44\x44\x44\xc7\x05\x00\x00\x40\x00"
+   "\x45\x45\x45\x45\x90\xc7\x05\x00\x00\x40\x00\x46\x46\x46\x46\xc7"
+   "\x05\x00\xf8\x3f\x00\x47\x47\x47\x47\xc7\x05\x00\x18\x40\x00\x48"
+   "\x48\x48\x48\xf4";
+// total size: 84 bytes
+
+/*
+bits 32
+
+; assumes code section at 0x100000
+; assumes data section at 0x200000, initially rw
+; assumes data section at 0x300000, initially rw
+; assumes data section at 0x400000, initially rw
+
+; with installed hooks unmaps or maps on each nop
+
+   mov dword [0x200000], 0x41414141 
+   nop                              ; mark it RO 
+   mov dword [0x200000], 0x42424242
+
+   mov dword [0x300000], 0x43434343
+   nop                              ; mark it RO 
+   mov dword [0x300000], 0x44444444
+
+   mov dword [0x400000], 0x45454545
+   nop                              ; mark it RO 
+   mov dword [0x400000], 0x46464646
+   mov dword [0x3ff800], 0x47474747 ; make sure surrounding areas remained RW
+   mov dword [0x401800], 0x48484848 ; make sure surrounding areas remained RW
+
+   hlt    ; tell hook function we are done
+*/
+
+int test_num  = 0;
+uint32_t tests[] = {
+   0x41414141,
+   0x43434343,
+   0x45454545
+};
+
+static int log_num = 1;
+
+#define CODE_SECTION 0x100000
+#define CODE_SIZE 0x1000
+
+// callback for tracing instruction
+static void hook_code(uch handle, uint64_t addr, uint32_t size, void *user_data)
+{
+   uint8_t opcode;
+   uint32_t testval;
+   if (uc_mem_read(handle, addr, &opcode, 1) != UC_ERR_OK) {
+      printf("not ok %d - uc_mem_read fail during hook_code callback, addr: 0x%" PRIx64 "\n", log_num++, addr);
+   }
+   printf("ok %d - uc_mem_read for opcode at address 0x%" PRIx64 "\n", log_num++, addr);
+   switch (opcode) {
+      case 0x90:  //nop
+         printf("# Handling NOP\n");
+         if (uc_mem_read(handle, 0x200000 + test_num * 0x100000, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_read fail for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
+         }
+         else {
+            printf("ok %d - good uc_mem_read for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
+            printf("# uc_mem_read for test %d\n", test_num);
+
+            if (testval == tests[test_num]) {
+               printf("ok %d - passed test %d\n", log_num++, test_num);
+            }
+            else {
+               printf("not ok %d - failed test %d\n", log_num++, test_num);
+               printf("# Expected: 0x%x\n",tests[test_num]);
+               printf("# Received: 0x%x\n", testval);
+            }
+         }
+         if (uc_mem_protect(handle, 0x200000 + test_num * 0x100000, 0x1000, UC_PROT_READ) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_protect fail during hook_code callback, addr: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
+         }
+         else {
+            printf("ok %d - uc_mem_protect success\n", log_num++);
+         }
+         test_num++;
+         break;
+      case 0xf4:  //hlt
+         printf("# Handling HLT\n");
+         if (uc_emu_stop(handle) != UC_ERR_OK) {
+            printf("not ok %d - uc_emu_stop fail during hook_code callback, addr: 0x%" PRIx64 "\n", log_num++, addr);
+            _exit(1);
+         }
+         else {
+            printf("ok %d - hlt encountered, uc_emu_stop called\n", log_num++);
+         }
+         break;
+      default:  //all others
+         printf("# Handling OTHER\n");
+         break;
+   }
+}
+
+// callback for tracing memory access (READ or WRITE)
+static void hook_mem_write(uch handle, uc_mem_type type,
+        uint64_t addr, int size, int64_t value, void *user_data)
+{
+   printf("# write to memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
+}
+
+// callback for tracing invalid memory access (READ or WRITE)
+static bool hook_mem_invalid(uch handle, uc_mem_type type,
+        uint64_t addr, int size, int64_t value, void *user_data)
+{
+   uint32_t testval;
+   switch(type) {
+      default:
+         printf("not ok %d - UC_HOOK_MEM_INVALID type: %d at 0x%" PRIx64 "\n", log_num++, type, addr);
+         return false;
+      case UC_MEM_WRITE_NW:
+         printf("# write to non-writeable memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
+
+         if (uc_mem_read(handle, addr, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_read fail for address: 0x%" PRIx64 "\n", log_num++, addr);
+         }
+         else {
+            printf("ok %d - uc_mem_read success after mem_protect at test %d\n", log_num++, test_num - 1);
+         }
+
+         if (uc_mem_protect(handle, addr & ~0xfff, 0x1000, UC_PROT_READ | UC_PROT_WRITE) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_protect fail during hook_mem_invalid callback, addr: 0x%" PRIx64 "\n", log_num++, addr);
+         }
+         else {
+            printf("ok %d - uc_mem_protect success\n", log_num++);
+         }
+         return true;
+   }
+}
+
+int main(int argc, char **argv, char **envp)
+{
+   uch handle, trace1, trace2;
+   uc_err err;
+   uint32_t addr, testval;
+   int32_t buf1[1024], buf2[1024], readbuf[1024];
+   int i;
+   
+   //don't really care about quality of randomness
+   srand(time(NULL));
+   for (i = 0; i < 1024; i++) {
+      buf1[i] = rand();
+      buf2[i] = rand();
+   }
+
+   printf("# Memory protect test\n");
+
+   // Initialize emulator in X86-32bit mode
+   err = uc_open(UC_ARCH_X86, UC_MODE_32, &handle);
+   if (err) {
+      printf("not ok %d - Failed on uc_open() with error returned: %u\n", log_num++, err);
+      return 1;
+   }
+   else {
+      printf("ok %d - uc_open() success\n", log_num++);
+   }
+
+   uc_mem_map(handle, CODE_SECTION, CODE_SIZE, UC_PROT_READ | UC_PROT_EXEC);
+   uc_mem_map(handle, 0x200000, 0x1000, UC_PROT_READ | UC_PROT_WRITE);
+   uc_mem_map(handle, 0x300000, 0x1000, UC_PROT_READ | UC_PROT_WRITE);
+   uc_mem_map(handle, 0x3ff000, 0x3000, UC_PROT_READ | UC_PROT_WRITE);
+
+   // fill in sections that shouldn't get touched
+   if (uc_mem_write(handle, 0x3ff000, (uint8_t*)buf1, 4096)) {
+      printf("not ok %d - Failed to write random buffer 1 to memory, quit!\n", log_num++);
+      return 2;
+   }
+   else {
+      printf("ok %d - Random buffer 1 written to memory\n", log_num++);
+   }
+
+   if (uc_mem_write(handle, 0x401000, (uint8_t*)buf2, 4096)) {
+      printf("not ok %d - Failed to write random buffer 2 to memory, quit!\n", log_num++);
+      return 2;
+   }
+   else {
+      printf("ok %d - Random buffer 2 written to memory\n", log_num++);
+   }
+
+   // write machine code to be emulated to memory
+   if (uc_mem_write(handle, CODE_SECTION, PROGRAM, sizeof(PROGRAM))) {
+      printf("not ok %d - Failed to write emulation code to memory, quit!\n", log_num++);
+      return 2;
+   }
+   else {
+      printf("ok %d - Program written to memory\n", log_num++);
+   }
+
+   if (uc_hook_add(handle, &trace2, UC_HOOK_CODE, hook_code, NULL, 1, 0) != UC_ERR_OK) {
+      printf("not ok %d - Failed to install UC_HOOK_CODE handler\n", log_num++);
+      return 3;
+   }
+   else {
+      printf("ok %d - UC_HOOK_CODE installed\n", log_num++);
+   }
+
+   // intercept memory write events
+   if (uc_hook_add(handle, &trace1, UC_HOOK_MEM_WRITE, hook_mem_write, NULL) != UC_ERR_OK) {
+      printf("not ok %d - Failed to install UC_HOOK_MEM_WRITE handler\n", log_num++);
+      return 4;
+   }
+   else {
+      printf("ok %d - UC_HOOK_MEM_WRITE installed\n", log_num++);
+   }
+
+   // intercept invalid memory events
+   if (uc_hook_add(handle, &trace1, UC_HOOK_MEM_INVALID, hook_mem_invalid, NULL) != UC_ERR_OK) {
+      printf("not ok %d - Failed to install UC_HOOK_MEM_INVALID handler\n", log_num++);
+      return 4;
+   }
+   else {
+      printf("ok %d - UC_HOOK_MEM_INVALID installed\n", log_num++);
+   }
+
+   // emulate machine code until told to stop by hook_code
+   printf("# BEGIN execution\n");
+   err = uc_emu_start(handle, CODE_SECTION, CODE_SECTION + CODE_SIZE, 0, 100);
+   if (err != UC_ERR_OK) {
+      printf("not ok %d - Failure on uc_emu_start() with error %u:%s\n", log_num++, err, uc_strerror(err));
+      return 5;
+   }
+   else {
+      printf("ok %d - uc_emu_start complete\n", log_num++);
+   }
+   printf("# END execution\n");
+
+   //read from the remapped memory
+   testval = 0x42424242;
+   for (addr = 0x200000; addr <= 0x400000; addr += 0x100000) {
+      uint32_t val;
+      if (uc_mem_read(handle, addr, (uint8_t*)&val, sizeof(val)) != UC_ERR_OK) {
+         printf("not ok %d - Failed uc_mem_read for address 0x%x\n", log_num++, addr);
+      }
+      else {
+         printf("ok %d - Good uc_mem_read from 0x%x\n", log_num++, addr);
+      }
+      if (val != testval) {
+         printf("not ok %d - Read 0x%x, expected 0x%x\n", log_num++, val, testval);
+      }
+      else {
+         printf("ok %d - Correct value retrieved\n", log_num++);
+      }
+      testval += 0x02020202;
+   }
+
+   //account for the two mods made by the machine code
+   buf1[512] = 0x47474747;
+   buf2[512] = 0x48484848;
+
+   //make sure that random blocks didn't get nuked
+   // fill in sections that shouldn't get touched
+   if (uc_mem_read(handle, 0x3ff000, (uint8_t*)readbuf, 4096)) {
+      printf("not ok %d - Failed to read random buffer 1 from memory\n", log_num++);
+   }
+   else {
+      printf("ok %d - Random buffer 1 read from memory\n", log_num++);
+      if (memcmp(buf1, readbuf, 4096)) {
+         printf("not ok %d - Random buffer 1 contents are incorrect\n", log_num++);
+      }
+      else {
+         printf("ok %d - Random buffer 1 contents are correct\n", log_num++);
+      }
+   }
+
+   if (uc_mem_read(handle, 0x401000, (uint8_t*)readbuf, 4096)) {
+      printf("not ok %d - Failed to read random buffer 2 from memory\n", log_num++);
+   }
+   else {
+      printf("ok %d - Random buffer 2 read from memory\n", log_num++);
+      if (memcmp(buf2, readbuf, 4096)) {
+         printf("not ok %d - Random buffer 2 contents are incorrect\n", log_num++);
+      }
+      else {
+         printf("ok %d - Random buffer 2 contents are correct\n", log_num++);
+      }
+   }
+
+   if (uc_close(&handle) == UC_ERR_OK) {
+      printf("ok %d - uc_close complete\n", log_num++);
+   }
+   else {
+      printf("not ok %d - uc_close complete\n", log_num++);
+   }
+
+   return 0;
+}
diff --git a/samples/mem_unmap.c b/samples/mem_unmap.c
new file mode 100755
index 00000000..60f3039a
--- /dev/null
+++ b/samples/mem_unmap.c
@@ -0,0 +1,313 @@
+/*
+
+uc_mem_unmap demo / unit test
+
+Copyright(c) 2015 Chris Eagle
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 2 as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+*/
+
+#define __STDC_FORMAT_MACROS
+#include <inttypes.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <unicorn/unicorn.h>
+
+unsigned char PROGRAM[] =
+   "\xc7\x05\x00\x00\x20\x00\x41\x41\x41\x41\x90\xc7\x05\x00\x00\x20"
+   "\x00\x42\x42\x42\x42\xc7\x05\x00\x00\x30\x00\x43\x43\x43\x43\x90"
+   "\xc7\x05\x00\x00\x30\x00\x44\x44\x44\x44\xc7\x05\x00\x00\x40\x00"
+   "\x45\x45\x45\x45\x90\xc7\x05\x00\x00\x40\x00\x46\x46\x46\x46\xf4";
+// total size: 64 bytes
+
+/*
+; assumes code section at 0x100000
+; assumes data section at 0x200000, initially rw
+; assumes data section at 0x300000, initially rw
+; assumes data section at 0x400000, initially rw
+
+; with installed hooks unmaps or maps on each nop
+
+   mov dword [0x200000], 0x41414141
+   nop                              ; unmap it
+   mov dword [0x200000], 0x42424242
+
+   mov dword [0x300000], 0x43434343
+   nop                              ; unmap it
+   mov dword [0x300000], 0x44444444
+
+   mov dword [0x400000], 0x45454545
+   nop                              ; unmap it
+   mov dword [0x400000], 0x46464646
+
+   hlt    ; tell hook function we are done
+*/
+
+int test_num  = 0;
+uint32_t tests[] = {
+   0x41414141,
+   0x43434343,
+   0x45454545
+};
+
+static int log_num = 1;
+
+#define CODE_SECTION 0x100000
+#define CODE_SIZE 0x1000
+
+// callback for tracing instruction
+static void hook_code(uch handle, uint64_t addr, uint32_t size, void *user_data)
+{
+   uint8_t opcode;
+   uint32_t testval;
+   if (uc_mem_read(handle, addr, &opcode, 1) != UC_ERR_OK) {
+      printf("not ok %d - uc_mem_read fail during hook_code callback, addr: 0x%" PRIx64 "\n", log_num++, addr);
+   }
+   printf("ok %d - uc_mem_read for opcode at address 0x%" PRIx64 "\n", log_num++, addr);
+   switch (opcode) {
+      case 0x90:  //nop
+         printf("# Handling NOP\n");
+         if (uc_mem_read(handle, 0x200000 + test_num * 0x100000, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_read fail for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
+         }
+         else {
+            printf("ok %d - good uc_mem_read for address: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
+            printf("# uc_mem_read for test %d\n", test_num);
+
+            if (testval == tests[test_num]) {
+               printf("ok %d - passed test %d\n", log_num++, test_num);
+            }
+            else {
+               printf("not ok %d - failed test %d\n", log_num++, test_num);
+               printf("# Expected: 0x%x\n",tests[test_num]);
+               printf("# Received: 0x%x\n", testval);
+            }
+         }
+         if (uc_mem_unmap(handle, 0x200000 + test_num * 0x100000, 0x1000) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_unmap fail during hook_code callback, addr: 0x%x\n", log_num++, 0x200000 + test_num * 0x100000);
+         }
+         else {
+            printf("ok %d - uc_mem_unmap success\n", log_num++);
+         }
+         test_num++;
+         break;
+      case 0xf4:  //hlt
+         printf("# Handling HLT\n");
+         if (uc_emu_stop(handle) != UC_ERR_OK) {
+            printf("not ok %d - uc_emu_stop fail during hook_code callback, addr: 0x%" PRIx64 "\n", log_num++, addr);
+            _exit(1);
+         }
+         else {
+            printf("ok %d - hlt encountered, uc_emu_stop called\n", log_num++);
+         }
+         break;
+      default:  //all others
+         printf("# Handling OTHER\n");
+         break;
+   }
+}
+
+// callback for tracing memory access (READ or WRITE)
+static void hook_mem_write(uch handle, uc_mem_type type,
+        uint64_t addr, int size, int64_t value, void *user_data)
+{
+   printf("# write to memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
+}
+
+// callback for tracing invalid memory access (READ or WRITE)
+static bool hook_mem_invalid(uch handle, uc_mem_type type,
+        uint64_t addr, int size, int64_t value, void *user_data)
+{
+   uint32_t testval;
+   switch(type) {
+      default:
+         printf("not ok %d - UC_HOOK_MEM_INVALID type: %d at 0x%" PRIx64 "\n", log_num++, type, addr);
+         return false;
+      case UC_MEM_WRITE:
+         printf("# write to invalid memory at 0x%"PRIx64 ", data size = %u, data value = 0x%"PRIx64 "\n", addr, size, value);
+
+         if (uc_mem_read(handle, addr, (uint8_t*)&testval, sizeof(testval)) != UC_ERR_OK) {
+            printf("ok %d - uc_mem_read fail for address: 0x%" PRIx64 "\n", log_num++, addr);
+         }
+         else {
+            printf("not ok %d - uc_mem_read success after unmap at test %d\n", log_num++, test_num - 1);
+         }
+
+         if (uc_mem_map(handle, addr & ~0xfff, 0x1000, UC_PROT_READ | UC_PROT_WRITE) != UC_ERR_OK) {
+            printf("not ok %d - uc_mem_map fail during hook_mem_invalid callback, addr: 0x%" PRIx64 "\n", log_num++, addr);
+         }
+         else {
+            printf("ok %d - uc_mem_map success\n", log_num++);
+         }
+         return true;
+   }
+}
+
+int main(int argc, char **argv, char **envp)
+{
+   uch handle, trace1, trace2;
+   uc_err err;
+   uint32_t addr, testval;
+   int32_t buf1[1024], buf2[1024], readbuf[1024];
+   int i;
+   
+   //don't really care about quality of randomness
+   srand(time(NULL));
+   for (i = 0; i < 1024; i++) {
+      buf1[i] = rand();
+      buf2[i] = rand();
+   }
+
+   printf("# Memory unmapping test\n");
+
+   // Initialize emulator in X86-32bit mode
+   err = uc_open(UC_ARCH_X86, UC_MODE_32, &handle);
+   if (err) {
+      printf("not ok %d - Failed on uc_open() with error returned: %u\n", log_num++, err);
+      return 1;
+   }
+   else {
+      printf("ok %d - uc_open() success\n", log_num++);
+   }
+
+   uc_mem_map(handle, CODE_SECTION, CODE_SIZE, UC_PROT_READ | UC_PROT_EXEC);
+   uc_mem_map(handle, 0x200000, 0x1000, UC_PROT_READ | UC_PROT_WRITE);
+   uc_mem_map(handle, 0x300000, 0x1000, UC_PROT_READ | UC_PROT_WRITE);
+   uc_mem_map(handle, 0x3ff000, 0x3000, UC_PROT_READ | UC_PROT_WRITE);
+
+   // fill in sections that shouldn't get touched
+   if (uc_mem_write(handle, 0x3ff000, (uint8_t*)buf1, 4096)) {
+      printf("not ok %d - Failed to write random buffer 1 to memory, quit!\n", log_num++);
+      return 2;
+   }
+   else {
+      printf("ok %d - Random buffer 1 written to memory\n", log_num++);
+   }
+
+   if (uc_mem_write(handle, 0x401000, (uint8_t*)buf2, 4096)) {
+      printf("not ok %d - Failed to write random buffer 2 to memory, quit!\n", log_num++);
+      return 2;
+   }
+   else {
+      printf("ok %d - Random buffer 2 written to memory\n", log_num++);
+   }
+
+   // write machine code to be emulated to memory
+   if (uc_mem_write(handle, CODE_SECTION, PROGRAM, sizeof(PROGRAM))) {
+      printf("not ok %d - Failed to write emulation code to memory, quit!\n", log_num++);
+      return 2;
+   }
+   else {
+      printf("ok %d - Program written to memory\n", log_num++);
+   }
+
+   if (uc_hook_add(handle, &trace2, UC_HOOK_CODE, hook_code, NULL, 1, 0) != UC_ERR_OK) {
+      printf("not ok %d - Failed to install UC_HOOK_CODE handler\n", log_num++);
+      return 3;
+   }
+   else {
+      printf("ok %d - UC_HOOK_CODE installed\n", log_num++);
+   }
+
+   // intercept memory write events
+   if (uc_hook_add(handle, &trace1, UC_HOOK_MEM_WRITE, hook_mem_write, NULL) != UC_ERR_OK) {
+      printf("not ok %d - Failed to install UC_HOOK_MEM_WRITE handler\n", log_num++);
+      return 4;
+   }
+   else {
+      printf("ok %d - UC_HOOK_MEM_WRITE installed\n", log_num++);
+   }
+
+   // intercept invalid memory events
+   if (uc_hook_add(handle, &trace1, UC_HOOK_MEM_INVALID, hook_mem_invalid, NULL) != UC_ERR_OK) {
+      printf("not ok %d - Failed to install UC_HOOK_MEM_INVALID handler\n", log_num++);
+      return 4;
+   }
+   else {
+      printf("ok %d - UC_HOOK_MEM_INVALID installed\n", log_num++);
+   }
+
+   // emulate machine code until told to stop by hook_code
+   printf("# BEGIN execution\n");
+   err = uc_emu_start(handle, CODE_SECTION, CODE_SECTION + CODE_SIZE, 0, 100);
+   if (err != UC_ERR_OK) {
+      printf("not ok %d - Failure on uc_emu_start() with error %u:%s\n", log_num++, err, uc_strerror(err));
+      return 5;
+   }
+   else {
+      printf("ok %d - uc_emu_start complete\n", log_num++);
+   }
+   printf("# END execution\n");
+
+   //read from the remapped memory
+   testval = 0x42424242;
+   for (addr = 0x200000; addr <= 0x400000; addr += 0x100000) {
+      uint32_t val;
+      if (uc_mem_read(handle, addr, (uint8_t*)&val, sizeof(val)) != UC_ERR_OK) {
+         printf("not ok %d - Failed uc_mem_read for address 0x%x\n", log_num++, addr);
+      }
+      else {
+         printf("ok %d - Good uc_mem_read from 0x%x\n", log_num++, addr);
+      }
+      if (val != testval) {
+         printf("not ok %d - Read 0x%x, expected 0x%x\n", log_num++, val, testval);
+      }
+      else {
+         printf("ok %d - Correct value retrieved\n", log_num++);
+      }
+      testval += 0x02020202;
+   }
+
+   //make sure that random blocks didn't get nuked
+   // fill in sections that shouldn't get touched
+   if (uc_mem_read(handle, 0x3ff000, (uint8_t*)readbuf, 4096)) {
+      printf("not ok %d - Failed to read random buffer 1 from memory\n", log_num++);
+   }
+   else {
+      printf("ok %d - Random buffer 1 read from memory\n", log_num++);
+      if (memcmp(buf1, readbuf, 4096)) {
+         printf("not ok %d - Random buffer 1 contents are incorrect\n", log_num++);
+      }
+      else {
+         printf("ok %d - Random buffer 1 contents are correct\n", log_num++);
+      }
+   }
+
+   if (uc_mem_read(handle, 0x401000, (uint8_t*)readbuf, 4096)) {
+      printf("not ok %d - Failed to read random buffer 2 from memory\n", log_num++);
+   }
+   else {
+      printf("ok %d - Random buffer 2 read from memory\n", log_num++);
+      if (memcmp(buf2, readbuf, 4096)) {
+         printf("not ok %d - Random buffer 2 contents are incorrect\n", log_num++);
+      }
+      else {
+         printf("ok %d - Random buffer 2 contents are correct\n", log_num++);
+      }
+   }
+
+   if (uc_close(&handle) == UC_ERR_OK) {
+      printf("ok %d - uc_close complete\n", log_num++);
+   }
+   else {
+      printf("not ok %d - uc_close complete\n", log_num++);
+   }
+
+   return 0;
+}
diff --git a/uc.c b/uc.c
index 6dc2786d..13b395cf 100644
--- a/uc.c
+++ b/uc.c
@@ -638,7 +638,7 @@ uc_err uc_mem_map(uch handle, uint64_t address, size_t size, uint32_t perms)
         return UC_ERR_MAP;
 
     // check for only valid permissions
-    if ((perms & ~(UC_PROT_READ | UC_PROT_WRITE | UC_PROT_EXEC)) != 0)
+    if ((perms & ~UC_PROT_ALL) != 0)
         return UC_ERR_MAP;
 
     if ((uc->mapped_block_count & (MEM_BLOCK_INCR - 1)) == 0) {  //time to grow
@@ -782,7 +782,7 @@ uc_err uc_mem_protect(uch handle, uint64_t address, size_t size, uint32_t perms)
         return UC_ERR_MAP;
 
     // check for only valid permissions
-    if ((perms & ~(UC_PROT_READ | UC_PROT_WRITE | UC_PROT_EXEC)) != 0)
+    if ((perms & ~UC_PROT_ALL) != 0)
         return UC_ERR_MAP;
         
     //check that user's entire requested block is mapped
@@ -790,50 +790,32 @@ uc_err uc_mem_protect(uch handle, uint64_t address, size_t size, uint32_t perms)
         return UC_ERR_MAP;
 
     //Now we know entire region is mapped, so change permissions
-    //check trivial case first
+    //If request exactly matches a region we don't need to split
     mr = memory_mapping(uc, address);
-    if (address == mr->addr && size == int128_get64(mr->size)) {
-        //regions exactly matches an existing region just change perms
-        mr->perms = perms;
-        uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0);
-    }
-    else {
+    if (address != mr->addr || size != int128_get64(mr->size)) {
         //ouch, we are going to need to subdivide blocks
-/*
-        address = start;
-        size = block_size;
-        while (size > 0) {
-            MemoryRegion *mr = memory_mapping(uc, address);
-            uint64_t region_size = int128_get64(mr->size);
-            if (address > mr->addr) {
-                //in case start address is not aligned with start of region
-                region_size -= address - mr->addr;
-                //TODO Learn how to split regions
-                //In this case some proper subset of the region is having it's permissions changed
-                //need to split region and add new portions into uc->mapped_blocks list
-                //In this case, there is a portion of the region with original perms: mr->addr..start
-                //and a portion getting new perms: start..start+block_size
-    
-                //split the block and stay in the loop
-            }
-            if (size < int128_get64(mr->size)) {
-                //TODO Learn how to split regions
-                //In this case some proper subset of the region is having it's permissions changed
-                //need to split region and add new portions into uc->mapped_blocks list
-                //In this case, there is a portion of the region with new perms: start..start+block_size
-                //and a portion getting new perms: mr->addr+size..mr->addr+mr->size
-    
-                //split the block and break
-                break;
-            }
-            size -= int128_get64(mr->size);
-            address += int128_get64(mr->size);
-            mr->perms = perms;
-            uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0);
+        uint64_t addr = address;
+        size_t count = 0, len;
+        while(count < size) {
+            MemoryRegion *mr = memory_mapping(uc, addr);
+            len = MIN(size - count, mr->end - addr);
+            if (!split_region(handle, mr, addr, len, false))
+                return UC_ERR_MAP;
+            count += len;
+            addr += len;
         }
-*/
-     }
-     return UC_ERR_OK;
+        //Grab a pointer to the newly split MemoryRegion
+        mr = memory_mapping(uc, address);
+        if (mr == NULL) {
+            //this should never happern if splitting succeeded
+            return UC_ERR_MAP;
+        }
+    }
+    //regions exactly matches an existing region just change perms
+    mr->perms = perms;
+    uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0);
+
+    return UC_ERR_OK;
 }
 
 UNICORN_EXPORT
@@ -842,7 +824,6 @@ uc_err uc_mem_unmap(uch handle, uint64_t address, size_t size)
     MemoryRegion *mr;
     unsigned int i;
     struct uc_struct* uc = (struct uc_struct *)handle;
-    size_t count, len;
 
     if (handle == 0)
         // invalid handle
@@ -882,7 +863,7 @@ uc_err uc_mem_unmap(uch handle, uint64_t address, size_t size)
      }
     else {
         //ouch, we are going to need to subdivide blocks
-        count = 0;
+        size_t count = 0, len;
         while(count < size) {
             MemoryRegion *mr = memory_mapping(uc, address);
             len = MIN(size - count, mr->end - address);