diff --git a/src/device.c b/src/device.c
index 2e77893..9693a6b 100644
--- a/src/device.c
+++ b/src/device.c
@@ -27,6 +27,9 @@ void freeDevMem(device_mem_t* devMem)
     free(devMem->rawCells);
     free(devMem->memreadCellAddrs);
     free(devMem->memwriteCellAddrs);
+    free(devMem->memwriteCellSegments);
+    free(devMem->memwriteValues[0]);
+    free(devMem->memwriteValues);
     free(devMem->cells);
     free(devMem->smartAddrReadHandlers);
     free(devMem->smartAddrWriteHandlers);
@@ -54,7 +57,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         return NULL;
     }
 
-    device_mem_t* devMem = (device_mem_t*)malloc(sizeof(device_mem_t));
+    device_mem_t* devMem = (device_mem_t*)calloc(1, sizeof(device_mem_t));
     if (devMem == NULL)
     {
         sprintf(errbuf, "unable to allocate dev memory struct");
@@ -71,7 +74,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         }
     }
 
-    void* rawCells = (void*)malloc(memTotalSize);
+    void* rawCells = (void*)calloc(memTotalSize, sizeof(void*));
     if (rawCells == NULL)
     {
         sprintf(errbuf, "unable to allocate raw memory buf");
@@ -84,7 +87,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         ((uint8_t*)rawCells)[i] = 0;
     }
 
-    devMem->memsegShifts = malloc(devSpec->memSpecsCount * sizeof(uint64_t));
+    devMem->memsegShifts = calloc(devSpec->memSpecsCount, sizeof(uint64_t));
 
     if(devMem->memsegShifts == NULL)
     {
@@ -94,7 +97,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         return NULL;
     }
 
-    void** cells = malloc(devSpec->memSpecsCount * sizeof(void*));
+    void** cells = calloc(devSpec->memSpecsCount, sizeof(void*));
 
     if (cells == NULL)
     {
@@ -107,10 +110,10 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
 
     for (uint8_t i = 0; i < devSpec->memSpecsCount; i++)
     {
-        cells[i] = rawCells + devSpec->memSpecs[i]->start;
+        cells[i] = (void*)((size_t)rawCells + (size_t)devSpec->memSpecs[i]->start);
     }
 
-    char** cellNames = malloc(sizeof(char*) * devSpec->memSpecsCount);
+    char** cellNames = calloc(devSpec->memSpecsCount, sizeof(char*));
 
     if(cellNames == NULL)
     {
@@ -127,7 +130,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         cellNames[i] = devSpec->memSpecs[i]->name;
     }
 
-    uint64_t* memreadCellAddrs = malloc(64 * sizeof(uint64_t));
+    uint64_t* memreadCellAddrs = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
     if (memreadCellAddrs == NULL)
     {
         sprintf(errbuf, "unable to allocate read interception addrs");
@@ -138,7 +141,7 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         free(cellNames);
         return NULL;
     }
-    uint64_t* memwriteCellAddrs = malloc(64 * sizeof(uint64_t));
+    uint64_t* memwriteCellAddrs = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
 
     if (memwriteCellAddrs == NULL)
     {
@@ -152,38 +155,96 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
         return NULL;
     }
 
-    uint64_t smartAddrReadMask = 0;
-    uint64_t smartAddrWriteMask = 0;
-    mem_h_read_handler* smartAddrReadHandlers = malloc(sizeof(mem_h_read_handler) * memTotalSize);
+    uint8_t* memwriteCellSegments = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint8_t));
 
-
-    if (smartAddrReadHandlers == NULL)
+    if(memwriteCellSegments == NULL)
     {
-        sprintf(errbuf, "unable to allocate read interception handlers");
-        free(memwriteCellAddrs);
+        sprintf(errbuf, "unable to allocate write interception addrs");
         free(devMem->memsegShifts);
         free(devMem);
         free(rawCells);
         free(memreadCellAddrs);
         free(cells);
         free(cellNames);
+        free(memwriteCellAddrs);
         return NULL;
     }
 
-    mem_h_write_handler* smartAddrWriteHandlers = malloc(sizeof(mem_h_write_handler) * memTotalSize);
+    void** memwriteValues = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(void*));
+
+    if(memwriteValues == NULL)
+    {
+        sprintf(errbuf, "unable to allocate write interception addrs");
+        free(devMem->memsegShifts);
+        free(devMem);
+        free(rawCells);
+        free(memreadCellAddrs);
+        free(cells);
+        free(cellNames);
+        free(memwriteCellAddrs);
+        free(memwriteCellSegments);
+        return NULL;
+    }
+
+    uint64_t* memwriteValuesContainers = calloc(MEM_ACCESS_INTERCEPT_BUF_SIZE, sizeof(uint64_t));
+    if(memwriteValuesContainers == NULL)
+    {
+        sprintf(errbuf, "unable to allocate write interception addrs");
+        free(devMem->memsegShifts);
+        free(devMem);
+        free(rawCells);
+        free(memreadCellAddrs);
+        free(cells);
+        free(cellNames);
+        free(memwriteCellAddrs);
+        free(memwriteCellSegments);
+        free(memwriteValues);
+        return NULL;
+    }
+
+    for(size_t i = 0; i < 64; i++)
+    {
+        memwriteValues[i] = &memwriteValuesContainers[i];
+    }
+
+    uint64_t smartAddrReadMask = 0;
+    uint64_t smartAddrWriteMask = 0;
+    mem_h_read_handler* smartAddrReadHandlers = calloc(memTotalSize, sizeof(mem_h_read_handler));
+
+
+    if (smartAddrReadHandlers == NULL)
+    {
+        sprintf(errbuf, "unable to allocate read interception handlers");
+        free(devMem->memsegShifts);
+        free(devMem);
+        free(rawCells);
+        free(memreadCellAddrs);
+        free(cells);
+        free(cellNames);
+        free(memwriteCellAddrs);
+        free(memwriteCellSegments);
+        free(memwriteValues);
+        free(memwriteValuesContainers);
+        return NULL;
+    }
+
+    mem_h_write_handler* smartAddrWriteHandlers = calloc(memTotalSize, sizeof(mem_h_write_handler));
 
 
     if (smartAddrWriteHandlers == NULL)
     {
         sprintf(errbuf, "unable to allocate write interception handlers");
         free(smartAddrReadHandlers);
-        free(memwriteCellAddrs);
         free(devMem->memsegShifts);
         free(devMem);
         free(rawCells);
         free(memreadCellAddrs);
         free(cells);
         free(cellNames);
+        free(memwriteCellAddrs);
+        free(memwriteCellSegments);
+        free(memwriteValues);
+        free(memwriteValuesContainers);
         return NULL;
     }
 
@@ -254,6 +315,8 @@ device_mem_t* genDevMem(device_specs_t* devSpec, char* errbuf)
     devMem->rawCells = rawCells;
     devMem->memreadCellAddrs = memreadCellAddrs;
     devMem->memwriteCellAddrs = memwriteCellAddrs;
+    devMem->memwriteCellSegments = memwriteCellSegments;
+    devMem->memwriteValues = memwriteValues;
     devMem->memreadLen = 0;
     devMem->memwriteLen = 0;
     devMem->smartAddrReadMask = smartAddrReadMask;
@@ -279,7 +342,7 @@ uint8_t makeDeviceTick(device_public_context_t* devContext)
 
 device_info_t* initSpecs(device_specs_t* specs, char* errbuf)
 {
-    device_info_t* devInfo = malloc(sizeof(device_info_t));
+    device_info_t* devInfo = calloc(1, sizeof(device_info_t));
     if (devInfo == NULL)
     {
         sprintf(errbuf, "unable to allocate dev info");
@@ -542,7 +605,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
 {
     return NULL;
     //TODO
-    device_specs_t* specs = malloc(sizeof(device_specs_t));
+    device_specs_t* specs = calloc(1, sizeof(device_specs_t));
     if (specs == NULL)
     {
         return NULL;
@@ -551,7 +614,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
 
 
     specs->memSpecsCount = 4;
-    specs->memSpecs = malloc(specs->memSpecsCount * sizeof(memseg_spec_t*));
+    specs->memSpecs = calloc(specs->memSpecsCount, sizeof(memseg_spec_t*));
     if (specs->memSpecs == NULL)
     {
         sprintf(errbuf, "unable to allocate default mem segment specs");
@@ -561,7 +624,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
 
 
     specs->executableSegmentsCount = 1;
-    specs->executableSegments = malloc(sizeof(uint8_t) * 1);
+    specs->executableSegments = calloc(1, sizeof(uint8_t));
     if (specs->executableSegments == NULL)
     {
         sprintf(errbuf, "unable to allocate default executable segments");
@@ -573,7 +636,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
 
     for (uint8_t i = 0; i < specs->memSpecsCount; i++) 
     {
-        specs->memSpecs[i] = malloc(sizeof(memseg_spec_t));
+        specs->memSpecs[i] = calloc(1, sizeof(memseg_spec_t));
         if (specs->memSpecs[i] == NULL)
         {
             sprintf(errbuf, "unable to allocate default mem seg spec %u", i);
@@ -622,7 +685,7 @@ device_public_context_t* initDefault(smart_read_spec_t* smartReadSpecs, uint64_t
 
 device_public_context_t* init(device_specs_t* specs, char* errbuf)
 {
-    device_public_context_t* pubDevContext = malloc(sizeof(device_public_context_t));
+    device_public_context_t* pubDevContext = calloc(1, sizeof(device_public_context_t));
     if (pubDevContext == NULL) 
     {
         sprintf(errbuf, "unable to allocate public context");