diff --git a/mps/qa/function/102.c b/mps/qa/function/102.c
new file mode 100644
index 00000000000..9b7e49fea12
--- /dev/null
+++ b/mps/qa/function/102.c
@@ -0,0 +1,174 @@
+/* TEST_HEADER
+ summary = EPDL allocation test
+ language = c
+ link = testlib.o
+END_HEADER
+*/
+
+#include <time.h>
+#include "testlib.h"
+#include "mpscepdl.h"
+#include "mpsavm.h"
+
+#define MAXNUMBER 1000000
+
+void *stackpointer;
+mps_space_t space;
+
+static struct {mps_addr_t addr; size_t size;} queue[MAXNUMBER];
+
+enum {SEQ=0, RAN=1, SEQGAP=2, RANGAP=3, DUMMY=4};
+static char *tdesc[] = {"sequential", "random",
+                        "sequential gap", "random gap", "dummy"};
+
+static void setobj(mps_addr_t a, size_t size, unsigned char val)
+{
+ unsigned char *b;
+ b = a;
+
+ while (size>0)
+ {
+  *b=val;
+ /* comment("%p = %i", b, (int) val);
+ */
+  b++;
+  size--;
+ }
+}
+
+static int chkobj(mps_addr_t a, size_t size, unsigned char val)
+{
+ unsigned char *b;
+ b = a;
+
+ while (size>0)
+ {
+ /* comment("%p == %i", b, (int) val);
+ */
+  if (*b != val) return 0;
+  b++;
+  size--;
+ }
+ return 1;
+}
+
+static void dt(int kind,
+   size_t extendBy, size_t avgSize, size_t maxSize,
+   size_t mins, size_t maxs, int number, int iter)
+{
+ mps_pool_t pool;
+ int i, hd;
+ clock_t time0, time1;
+ size_t size;
+ int secs;
+
+ asserts(number <= MAXNUMBER, "number too big");
+
+ time0 = clock();
+ asserts(time0 != -1, "processor time not available");
+
+ die(
+  mps_pool_create(&pool, space, mps_class_epdl(),
+                  extendBy, avgSize, maxSize),
+  "create pool");
+
+ for(hd=0; hd<number; hd++)
+ {
+  size = ranrange(mins, maxs);
+  if ((ranint(2) && (kind & 2)) || (kind==DUMMY))
+  {
+   queue[hd].addr=NULL;
+  }
+  else
+  {
+   die(mps_alloc(&queue[hd].addr, pool, size), "alloc");
+   setobj(queue[hd].addr, size, (unsigned char) (hd%256));
+   queue[hd].size = size;
+  }
+ };
+
+ hd=-1;
+
+ for(i=0; i<iter; i++)
+ {
+   if (kind & 1) hd = ranint(number);
+   else {ranint(number); hd=(hd+1)%number;} /* call raninit anyway
+                                               to use same time */
+
+   if (queue[hd].addr != NULL)
+   {
+    asserts(chkobj(queue[hd].addr, queue[hd].size, (unsigned char) (hd%256)),
+      "corrupt at %x (%s: %x, %x, %x, %x, %x, %i, %i)",
+      queue[hd].addr,
+      tdesc[kind], (int) extendBy, (int) avgSize, (int) maxSize,
+      (int) mins, (int) maxs, number, iter);
+    mps_free(pool, queue[hd].addr, queue[hd].size);
+   }
+   size = ranrange(mins, maxs);
+
+   if ((ranint(2) && (kind & 2)) || (kind==DUMMY))
+   {
+    queue[hd].addr=NULL;
+   }
+   else
+   {
+    die(mps_alloc(&queue[hd].addr, pool, size),"alloc");
+    setobj(queue[hd].addr, size, (unsigned char) (hd%256));
+    queue[hd].size = size;
+   }
+ }
+
+ mps_pool_destroy(pool);
+
+ time1=clock();
+ secs=(int) 100*(time1-time0)/CLOCKS_PER_SEC;
+
+ comment("%s test (%x, %x, %x, %x, %x, %i, %i) in %i centisecs",
+  tdesc[kind], (int) extendBy, (int) avgSize, (int) maxSize,
+  (int) mins, (int) maxs, number, iter, secs);
+}
+
+static void test(void)
+{
+ mps_thr_t thread;
+ size_t mins;
+
+ cdie(mps_arena_create(&space, mps_arena_class_vm(), (size_t) (1024*1024*50)), "create space");
+ cdie(mps_thread_reg(&thread, space), "register thread");
+
+ mins = sizeof(int);
+
+ dt(SEQ, 4096, 32, 64*1024, 8, 9, 5, 10);
+ dt(RANGAP, 64, 64, 64, 8, 128, 100, 1000);
+
+ dt(DUMMY, 4096, 32, 64*1024, 8, 64, 1000, 10000);
+ dt(SEQ, 4096, 32, 64*1024, 8, 64, 1000, 10000);
+ dt(RAN, 4096, 32, 64*1024, 8, 64, 1000, 10000);
+ dt(SEQGAP, 4096, 32, 64*1024, 8, 64, 1000, 10000);
+ dt(RANGAP, 4096, 32, 64*1024, 8, 64, 1000, 10000);
+
+ dt(DUMMY, 4096, 1024, 64*1024, 100, 132, 1000, 10000);
+ dt(SEQ, 4096, 1024, 64*1024, 100, 132, 1000, 10000);
+ dt(RAN, 4096, 1024, 64*1024, 100, 132, 1000, 10000);
+ dt(SEQGAP, 4096, 1024, 64*1024, 100, 132, 1000, 10000);
+ dt(RANGAP, 4096, 1024, 64*1024, 100, 132, 1000, 10000);
+
+ dt(DUMMY, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000);
+ dt(SEQ, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000);
+ dt(RAN, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000);
+ dt(SEQGAP, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000);
+ dt(RANGAP, 128*1024, 64*1024, 6400*1024, mins, 128*1024, 100, 10000);
+
+ mps_thread_dereg(thread);
+ mps_arena_destroy(space);
+}
+
+int main(void)
+{
+ void *m;
+ stackpointer=&m; /* hack to get stack pointer */
+
+ easy_tramp(test);
+ pass();
+ return 0;
+}
diff --git a/mps/qa/function/82.c b/mps/qa/function/82.c
new file mode 100644
index 00000000000..20a7b63180a
--- /dev/null
+++ b/mps/qa/function/82.c
@@ -0,0 +1,138 @@
+/* TEST_HEADER
+ summary = EPVM save, alloc, restore in two pools
+ language = c
+ link = testlib.o epvmfmt.o
+END_HEADER
+*/
+
+#include "testlib.h"
+#include "mpscepvm.h"
+#include "mpsavm.h"
+#include "epvmfmt.h"
+
+#define MAX_SAVE 20
+#define INIT_SAVE 3
+
+void *stackpointer;
+
+static void test(void)
+{
+ mps_arena_t arena;
+ mps_pool_t pool1, pool2;
+ mps_thr_t thread;
+ mps_root_t root;
+
+ mps_fmt_t format;
+ mps_ap_t ap1p, ap1s, ap2p, ap2s;
+
+ psobj *a;
+
+ int i, j;
+
+ mps_epvm_save_level_t lev1, lev2;
+
+/* create an arena that can't grow beyond 64M */
+
+ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)),
+  "create arena");
+
+ cdie(mps_thread_reg(&thread, arena), "register thread");
+
+ cdie(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
+   mps_stack_scan_ambig, stackpointer, 0),
+  "create root");
+
+ cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format");
+
+ cdie(mps_pool_create(&pool1, arena, mps_class_epvm(),
+   format, MAX_SAVE, INIT_SAVE), "create pool1");
+
+ cdie(mps_pool_create(&pool2, arena, mps_class_epvm(),
+   format, MAX_SAVE, INIT_SAVE), "create pool2");
+ 
+ cdie(mps_ap_create(&ap1p, pool1, 1), "create ap1p");
+ cdie(mps_ap_create(&ap1s, pool1, 0), "create ap1s");
+ cdie(mps_ap_create(&ap2p, pool2, 1), "create ap2p");
+ cdie(mps_ap_create(&ap2s, pool2, 0), "create ap2s");
+
+ lev1 = INIT_SAVE;
+ lev2 = INIT_SAVE;
+
+ for (i=0; i<100000; i++) {
+  if (i % 1000 ==0) {
+   comment("---------------------- Restore to zero.");
+   if (lev1 > 0) {
+    lev1 = 0;
+    mps_epvm_restore(pool1, lev1);
+   }
+   if (lev2 > 0) {
+    lev2 = 0;
+    mps_epvm_restore(pool2, lev2);
+   }
+  }
+  j = ranint(40);
+  switch (j)  {
+   case 1:
+    if (lev1==0) break;
+    lev1--;
+    comment("Restore 1: %i", lev1);
+    while (ranint(2) && (lev1>0)) lev1--;
+    mps_epvm_restore(pool1, lev1);
+    break;
+   case 2:
+    if (lev2==0) break;
+    lev2--;
+    while (ranint(2) && (lev2>0)) lev2--;
+    comment("Restore 2: %i", lev2);
+    mps_epvm_restore(pool2, lev2);
+    break;
+   case 3:
+   case 4:
+    if (lev1<MAX_SAVE) {
+     lev1++;
+     comment("Save 1 to %i", lev1);
+     mps_epvm_save(pool1);
+    }
+    break;
+   case 5:
+   case 6:
+    if (lev2<MAX_SAVE) {
+     lev2++;
+     comment("Save 2 to %i", lev2);
+     mps_epvm_save(pool2);
+    }
+    break;
+   default:
+    if (ranint(2)==0) {
+     a = allocepvm(ap1p, 8*(ranint(1000)+1));
+    } else {
+     a = allocepvm(ap2p, 8*(ranint(1000)+1));
+    }
+  }
+ }
+
+ mps_ap_destroy(ap1p);
+ mps_ap_destroy(ap1s);
+ mps_ap_destroy(ap2p);
+ mps_ap_destroy(ap2s);
+ mps_pool_destroy(pool1);
+ mps_pool_destroy(pool2);
+ mps_fmt_destroy(format);
+ mps_root_destroy(root);
+ mps_thread_dereg(thread);
+ mps_arena_destroy(arena);
+ comment("Destroyed arena");
+
+}
+
+int main(void) {
+ void *m;
+ stackpointer=&m;
+
+ easy_tramp(test);
+ pass();
+ return 0;
+}
+
+
+
diff --git a/mps/qa/function/84.c b/mps/qa/function/84.c
new file mode 100644
index 00000000000..7d7cafd74ee
--- /dev/null
+++ b/mps/qa/function/84.c
@@ -0,0 +1,112 @@
+/* TEST_HEADER
+ summary = EPVM save, alloc, restore in one pool
+ language = c
+ link = testlib.o epvmfmt.o
+END_HEADER
+*/
+
+#include "testlib.h"
+#include "mpscepvm.h"
+#include "mpsavm.h"
+#include "epvmfmt.h"
+
+#define MAX_SAVE 20
+#define INIT_SAVE 3
+
+void *stackpointer;
+
+static void test(void)
+{
+ mps_arena_t arena;
+ mps_pool_t pool1;
+ mps_thr_t thread;
+ mps_root_t root;
+
+ mps_fmt_t format;
+ mps_ap_t ap1p;
+
+ psobj *a;
+
+ int i, j;
+
+ mps_epvm_save_level_t lev1;
+
+/* create an arena that can't grow beyond 64M */
+
+ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)),
+  "create arena");
+
+ cdie(mps_thread_reg(&thread, arena), "register thread");
+
+ cdie(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
+   mps_stack_scan_ambig, stackpointer, 0),
+  "create root");
+
+ cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format");
+
+ cdie(mps_pool_create(&pool1, arena, mps_class_epvm(),
+   format, MAX_SAVE, INIT_SAVE), "create pool1");
+ 
+ cdie(mps_ap_create(&ap1p, pool1, 1), "create ap1p");
+
+ lev1 = INIT_SAVE;
+
+ for (i=0; i<100000; i++) {
+  if (i % 1000 ==0) {
+   comment("---------------------- Restore to zero.");
+   if (lev1 > 0) {
+    lev1 = 0;
+    mps_epvm_restore(pool1, lev1);
+   }
+  }
+  j = ranint(40);
+  switch (j)  {
+   case 1:
+    if (lev1==0) break;
+    lev1--;
+    comment("Restore to %i", lev1);
+    while (ranint(2) && (lev1>0)) lev1--;
+    mps_epvm_restore(pool1, lev1);
+    break;
+   case 2:
+    break;
+   case 3:
+   case 4:
+    if (lev1<MAX_SAVE) {
+     lev1++;
+     comment("Save to %i", lev1);
+     mps_epvm_save(pool1);
+    }
+    break;
+   case 5:
+   case 6:
+    break;
+   default:
+    if (ranint(2)==0) {
+     a = allocepvm(ap1p, 8*(ranint(1000)+1));
+    } else {
+    }
+  }
+ }
+
+ mps_ap_destroy(ap1p);
+ mps_pool_destroy(pool1);
+ mps_fmt_destroy(format);
+ mps_root_destroy(root);
+ mps_thread_dereg(thread);
+ mps_arena_destroy(arena);
+ comment("Destroyed arena");
+
+}
+
+int main(void) {
+ void *m;
+ stackpointer=&m;
+
+ easy_tramp(test);
+ pass();
+ return 0;
+}
+
+
+
diff --git a/mps/qa/function/85.c b/mps/qa/function/85.c
new file mode 100644
index 00000000000..13f246df9f6
--- /dev/null
+++ b/mps/qa/function/85.c
@@ -0,0 +1,115 @@
+/* TEST_HEADER
+ summary = EPVM save, alloc, restore (singly) in one pool
+ language = c
+ link = testlib.o epvmfmt.o
+END_HEADER
+*/
+
+#include "testlib.h"
+#include "mpscepvm.h"
+#include "mpsavm.h"
+#include "epvmfmt.h"
+
+#define MAX_SAVE 20
+#define INIT_SAVE 3
+
+void *stackpointer;
+
+static void test(void)
+{
+ mps_arena_t arena;
+ mps_pool_t pool1;
+ mps_thr_t thread;
+ mps_root_t root;
+
+ mps_fmt_t format;
+ mps_ap_t ap1p;
+
+ psobj *a;
+
+ int i, j;
+
+ mps_epvm_save_level_t lev1;
+
+/* create an arena that can't grow beyond 64M */
+
+ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)),
+  "create arena");
+
+ cdie(mps_thread_reg(&thread, arena), "register thread");
+
+ cdie(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
+   mps_stack_scan_ambig, stackpointer, 0),
+  "create root");
+
+ cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format");
+
+ cdie(mps_pool_create(&pool1, arena, mps_class_epvm(),
+   format, MAX_SAVE, INIT_SAVE), "create pool1");
+ 
+ cdie(mps_ap_create(&ap1p, pool1, 1), "create ap1p");
+
+ lev1 = INIT_SAVE;
+
+ for (i=0; i<100000; i++) {
+  if (i % 1000 ==0) {
+   comment("---------------------- Restore to zero.");
+   while (lev1 > 0) {
+    lev1--;
+    mps_epvm_restore(pool1, lev1);
+   }
+  }
+  j = ranint(40);
+  switch (j)  {
+   case 1:
+    if (lev1==0) break;
+    lev1--;
+    mps_epvm_restore(pool1, lev1);
+    comment("Restore to %i", lev1);
+    while (ranint(2) && (lev1>0)) {
+     lev1--;
+     mps_epvm_restore(pool1, lev1);
+    }
+    break;
+   case 2:
+    break;
+   case 3:
+   case 4:
+    if (lev1<MAX_SAVE) {
+     lev1++;
+     comment("Save to %i", lev1);
+     mps_epvm_save(pool1);
+    }
+    break;
+   case 5:
+   case 6:
+    break;
+   default:
+    if (ranint(2)==0) {
+     a = allocepvm(ap1p, 8*(ranint(1000)+1));
+    } else {
+    }
+  }
+ }
+
+ mps_ap_destroy(ap1p);
+ mps_pool_destroy(pool1);
+ mps_fmt_destroy(format);
+ mps_root_destroy(root);
+ mps_thread_dereg(thread);
+ mps_arena_destroy(arena);
+ comment("Destroyed arena");
+
+}
+
+int main(void) {
+ void *m;
+ stackpointer=&m;
+
+ easy_tramp(test);
+ pass();
+ return 0;
+}
+
+
+
diff --git a/mps/qa/function/86.c b/mps/qa/function/86.c
new file mode 100644
index 00000000000..f354c1194a4
--- /dev/null
+++ b/mps/qa/function/86.c
@@ -0,0 +1,127 @@
+/* TEST_HEADER
+ summary = EPVM error on destroying pools
+ language = c
+ link = testlib.o epvmfmt.o
+END_HEADER
+*/
+
+#include "testlib.h"
+#include "mpscepvm.h"
+#include "mpsavm.h"
+#include "epvmfmt.h"
+
+#define MAX_SAVE 20
+#define INIT_SAVE 3
+
+void *stackpointer;
+
+static void test(void)
+{
+ mps_arena_t arena;
+ mps_pool_t pool1, pool2;
+ mps_thr_t thread;
+ mps_root_t root;
+
+ mps_fmt_t format;
+ mps_ap_t ap1p, ap1s, ap2p, ap2s;
+
+ psobj *a;
+
+ int i, j;
+
+ mps_epvm_save_level_t lev1, lev2;
+
+/* create an arena that can't grow beyond 64M */
+
+ cdie(mps_arena_create(&arena, mps_arena_class_vm(), (size_t) (1024*1024*64)),
+  "create arena");
+
+ cdie(mps_thread_reg(&thread, arena), "register thread");
+
+ cdie(mps_root_create_reg(&root, arena, MPS_RANK_AMBIG, 0, thread,
+   mps_stack_scan_ambig, stackpointer, 0),
+  "create root");
+
+ cdie(mps_fmt_create_A(&format, arena, &fmtepvm), "create format");
+
+ cdie(mps_pool_create(&pool1, arena, mps_class_epvm(),
+   format, MAX_SAVE, INIT_SAVE), "create pool1");
+
+ cdie(mps_pool_create(&pool2, arena, mps_class_epvm(),
+   format, MAX_SAVE, INIT_SAVE), "create pool2");
+ 
+ cdie(mps_ap_create(&ap1p, pool1, 1), "create ap1p");
+ cdie(mps_ap_create(&ap1s, pool1, 0), "create ap1s");
+ cdie(mps_ap_create(&ap2p, pool2, 1), "create ap2p");
+ cdie(mps_ap_create(&ap2s, pool2, 0), "create ap2s");
+
+ lev1 = INIT_SAVE;
+ lev2 = INIT_SAVE;
+
+ for (i=0; i<10000; i++) {
+  j = ranint(40);
+  switch (j)  {
+   case 1:
+    if (lev1==0) break;
+    lev1--;
+    comment("Restore 1: %i", lev1);
+    while (ranint(2) && (lev1>0)) lev1--;
+    mps_epvm_restore(pool1, lev1);
+    break;
+   case 2:
+    if (lev2==0) break;
+    lev2--;
+    while (ranint(2) && (lev2>0)) lev2--;
+    comment("Restore 2: %i", lev2);
+    mps_epvm_restore(pool2, lev2);
+    break;
+   case 3:
+   case 4:
+    if (lev1<MAX_SAVE) {
+     lev1++;
+     comment("Save 1 to %i", lev1);
+     mps_epvm_save(pool1);
+    }
+    break;
+   case 5:
+   case 6:
+    if (lev2<MAX_SAVE) {
+     lev2++;
+     comment("Save 2 to %i", lev2);
+     mps_epvm_save(pool2);
+    }
+    break;
+   default:
+    if (ranint(2)==0) {
+     a = allocepvm(ap1p, 8*(ranint(10)+1));
+    } else {
+     a = allocepvm(ap2p, 8*(ranint(10)+1));
+    }
+  }
+ }
+
+ mps_ap_destroy(ap1p);
+ mps_ap_destroy(ap1s);
+ mps_ap_destroy(ap2p);
+ mps_ap_destroy(ap2s);
+ mps_pool_destroy(pool1);
+ mps_pool_destroy(pool2);
+ mps_fmt_destroy(format);
+ mps_root_destroy(root);
+ mps_thread_dereg(thread);
+ mps_arena_destroy(arena);
+ comment("Destroyed arena");
+
+}
+
+int main(void) {
+ void *m;
+ stackpointer=&m;
+
+ easy_tramp(test);
+ pass();
+ return 0;
+}
+
+
+