diff --git a/dlls/dbghelp/storage.c b/dlls/dbghelp/storage.c
index e196143..6538272 100644
--- a/dlls/dbghelp/storage.c
+++ b/dlls/dbghelp/storage.c
@@ -32,100 +32,28 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
 
-struct pool_arena
-{
-    struct pool_arena*  next;
-    char*               current;
-};
-
 void pool_init(struct pool* a, unsigned arena_size)
 {
-    a->arena_size = arena_size;
-    a->first = NULL;
+    return;
 }
 
 void pool_destroy(struct pool* pool)
 {
-    struct pool_arena*  arena;
-    struct pool_arena*  next;
-
-#ifdef USE_STATS
-    unsigned    alloc, used, num;
-    
-    for (alloc = used = num = 0, arena = pool->first; arena; arena = arena->next)
-    {
-        alloc += pool->arena_size;
-        used += arena->current - (char*)arena;
-        num++;
-    }
-    FIXME("STATS: pool %p has allocated %u kbytes, used %u kbytes in %u arenas,\n"
-          "\t\t\t\tnon-allocation ratio: %.2f%%\n",
-          pool, alloc >> 10, used >> 10, num, 100.0 - (float)used / (float)alloc * 100.0);
-#endif
-
-    for (arena = pool->first; arena; arena = next)
-    {
-        next = arena->next;
-        HeapFree(GetProcessHeap(), 0, arena);
-    }
-    pool_init(pool, 0);
+    return;
 }
 
 void* pool_alloc(struct pool* pool, unsigned len)
 {
-    struct pool_arena** parena;
-    struct pool_arena*  arena;
-    void*               ret;
-
-    len = (len + 3) & ~3; /* round up size on DWORD boundary */
-    assert(sizeof(struct pool_arena) + len <= pool->arena_size && len);
-
-    for (parena = &pool->first; *parena; parena = &(*parena)->next)
-    {
-        if ((char*)(*parena) + pool->arena_size - (*parena)->current >= len)
-        {
-            ret = (*parena)->current;
-            (*parena)->current += len;
-            return ret;
-        }
-    }
- 
-    arena = HeapAlloc(GetProcessHeap(), 0, pool->arena_size);
-    if (!arena) {FIXME("OOM\n");return NULL;}
-
-    *parena = arena;
-
-    ret = (char*)arena + sizeof(*arena);
-    arena->next = NULL;
-    arena->current = (char*)ret + len;
-    return ret;
-}
-
-static struct pool_arena* pool_is_last(const struct pool* pool, const void* p, unsigned old_size)
-{
-    struct pool_arena*  arena;
-
-    for (arena = pool->first; arena; arena = arena->next)
-    {
-        if (arena->current == (const char*)p + old_size) return arena;
-    }
-    return NULL;
+    return HeapAlloc(GetProcessHeap(), 0, len);
 }
 
 static void* pool_realloc(struct pool* pool, void* p, unsigned old_size, unsigned new_size)
 {
-    struct pool_arena*  arena;
-    void*               new;
-
-    if ((arena = pool_is_last(pool, p, old_size)) && 
-        (char*)p + new_size <= (char*)arena + pool->arena_size)
-    {
-        arena->current = (char*)p + new_size;
-        return p;
+    if(p){
+        return HeapReAlloc(GetProcessHeap(), 0, p, new_size);
+    } else {
+        return HeapAlloc(GetProcessHeap(), 0, new_size);
     }
-    if ((new = pool_alloc(pool, new_size)) && old_size)
-        memcpy(new, p, min(old_size, new_size));
-    return new;
 }
 
 char* pool_strdup(struct pool* pool, const char* str)