diff --git a/vm/boostenv/main/cached/Abstraction-implem-decl-after.hh b/vm/boostenv/main/cached/Abstraction-implem-decl-after.hh
index f1e5c94d2..b4c4994a7 100644
--- a/vm/boostenv/main/cached/Abstraction-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Abstraction-implem-decl-after.hh
@@ -51,44 +51,44 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void setUUID(VM vm, const struct mozart::UUID & uuid);
+  void setUUID(mozart::VM vm, const mozart::UUID & uuid);
 };
diff --git a/vm/boostenv/main/cached/Abstraction-implem-decl.hh b/vm/boostenv/main/cached/Abstraction-implem-decl.hh
index 5253c6a09..2ee7301e8 100644
--- a/vm/boostenv/main/cached/Abstraction-implem-decl.hh
+++ b/vm/boostenv/main/cached/Abstraction-implem-decl.hh
@@ -3,5 +3,5 @@ class Abstraction;
 template <>
 class Storage<Abstraction> {
 public:
-  typedef ImplWithArray<Abstraction, class mozart::StableNode> Type;
+  typedef ImplWithArray<Abstraction, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Abstraction-implem.hh b/vm/boostenv/main/cached/Abstraction-implem.hh
index 737474ce8..87fe9ffba 100644
--- a/vm/boostenv/main/cached/Abstraction-implem.hh
+++ b/vm/boostenv/main/cached/Abstraction-implem.hh
@@ -47,16 +47,16 @@ size_t TypedRichNode<Abstraction>::getArraySize() {
   return _self.access<Abstraction>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Abstraction>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Abstraction>::getElementsArray() {
   return _self.access<Abstraction>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Abstraction>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Abstraction>::getElements(size_t i) {
   return _self.access<Abstraction>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Abstraction>::home() {
+mozart::Space *  TypedRichNode<Abstraction>::home() {
   return _self.access<Abstraction>().home();
 }
 
@@ -66,51 +66,51 @@ size_t  TypedRichNode<Abstraction>::getArraySizeImpl() {
 }
 
 inline
-atom_t  TypedRichNode<Abstraction>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Abstraction>::getPrintName(mozart::VM vm) {
   return _self.access<Abstraction>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Abstraction>::isCallable(VM vm) {
+bool  TypedRichNode<Abstraction>::isCallable(mozart::VM vm) {
   return _self.access<Abstraction>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<Abstraction>::isProcedure(VM vm) {
+bool  TypedRichNode<Abstraction>::isProcedure(mozart::VM vm) {
   return _self.access<Abstraction>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<Abstraction>::procedureArity(VM vm) {
+size_t  TypedRichNode<Abstraction>::procedureArity(mozart::VM vm) {
   return _self.access<Abstraction>().procedureArity(vm);
 }
 
 inline
-void  TypedRichNode<Abstraction>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<Abstraction>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<Abstraction>().getCallInfo(vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<Abstraction>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<Abstraction>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<Abstraction>().getDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<Abstraction>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Abstraction>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Abstraction>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Abstraction>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Abstraction>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Abstraction>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<Abstraction>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<Abstraction>::globalize(mozart::VM vm) {
   return _self.access<Abstraction>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<Abstraction>::setUUID(VM vm, const struct mozart::UUID & uuid) {
+void  TypedRichNode<Abstraction>::setUUID(mozart::VM vm, const mozart::UUID & uuid) {
   _self.access<Abstraction>().setUUID(_self, vm, uuid);
 }
diff --git a/vm/boostenv/main/cached/Arity-implem-decl-after.hh b/vm/boostenv/main/cached/Arity-implem-decl-after.hh
index d7b8bc912..bd95ec320 100644
--- a/vm/boostenv/main/cached/Arity-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Arity-implem-decl-after.hh
@@ -48,32 +48,32 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getLabel();
+  mozart::StableNode * getLabel();
 
   inline
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, size_t & offset);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, size_t & offset);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/Arity-implem-decl.hh b/vm/boostenv/main/cached/Arity-implem-decl.hh
index 593265840..0cb720eae 100644
--- a/vm/boostenv/main/cached/Arity-implem-decl.hh
+++ b/vm/boostenv/main/cached/Arity-implem-decl.hh
@@ -3,5 +3,5 @@ class Arity;
 template <>
 class Storage<Arity> {
 public:
-  typedef ImplWithArray<Arity, class mozart::StableNode> Type;
+  typedef ImplWithArray<Arity, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Arity-implem.hh b/vm/boostenv/main/cached/Arity-implem.hh
index 72f71a9dc..a59488bb4 100644
--- a/vm/boostenv/main/cached/Arity-implem.hh
+++ b/vm/boostenv/main/cached/Arity-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Arity>::getArraySize() {
   return _self.access<Arity>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Arity>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Arity>::getElementsArray() {
   return _self.access<Arity>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Arity>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Arity>::getElements(size_t i) {
   return _self.access<Arity>().getElements(i);
 }
 
@@ -48,7 +48,7 @@ size_t  TypedRichNode<Arity>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Arity>::getLabel() {
+mozart::StableNode *  TypedRichNode<Arity>::getLabel() {
   return _self.access<Arity>().getLabel();
 }
 
@@ -58,26 +58,26 @@ size_t  TypedRichNode<Arity>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Arity>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Arity>::getElement(size_t index) {
   return _self.access<Arity>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Arity>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Arity>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Arity>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Arity>::lookupFeature(VM vm, class mozart::RichNode feature, size_t & offset) {
+bool  TypedRichNode<Arity>::lookupFeature(mozart::VM vm, mozart::RichNode feature, size_t & offset) {
   return _self.access<Arity>().lookupFeature(vm, feature, offset);
 }
 
 inline
-void  TypedRichNode<Arity>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Arity>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Arity>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Arity>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Arity>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Arity>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/Array-implem-decl-after.hh b/vm/boostenv/main/cached/Array-implem-decl-after.hh
index 087d435fb..ea0066def 100644
--- a/vm/boostenv/main/cached/Array-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Array-implem-decl-after.hh
@@ -45,19 +45,19 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::UnstableNode> getElementsArray();
+  StaticArray<mozart::UnstableNode> getElementsArray();
 
   inline
-  class mozart::UnstableNode& getElements(size_t i);
+  mozart::UnstableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
   size_t getArraySizeImpl();
@@ -66,35 +66,35 @@ public:
   size_t getWidth();
 
   inline
-  nativeint getLow();
+  mozart::nativeint getLow();
 
   inline
-  nativeint getHigh();
+  mozart::nativeint getHigh();
 
   inline
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  bool isArray(VM vm);
+  bool isArray(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayLow(VM vm);
+  mozart::UnstableNode arrayLow(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayHigh(VM vm);
+  mozart::UnstableNode arrayHigh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayGet(VM vm, class mozart::RichNode index);
+  mozart::UnstableNode arrayGet(mozart::VM vm, mozart::RichNode index);
 
   inline
-  void arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value);
+  void arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue);
+  mozart::UnstableNode arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Array-implem-decl.hh b/vm/boostenv/main/cached/Array-implem-decl.hh
index 8f404ef0c..2261a660b 100644
--- a/vm/boostenv/main/cached/Array-implem-decl.hh
+++ b/vm/boostenv/main/cached/Array-implem-decl.hh
@@ -3,5 +3,5 @@ class Array;
 template <>
 class Storage<Array> {
 public:
-  typedef ImplWithArray<Array, class mozart::UnstableNode> Type;
+  typedef ImplWithArray<Array, mozart::UnstableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Array-implem.hh b/vm/boostenv/main/cached/Array-implem.hh
index 44aee40ce..b31ba7d4e 100644
--- a/vm/boostenv/main/cached/Array-implem.hh
+++ b/vm/boostenv/main/cached/Array-implem.hh
@@ -37,26 +37,26 @@ size_t TypedRichNode<Array>::getArraySize() {
   return _self.access<Array>().getArraySize();
 }
 
-StaticArray<class mozart::UnstableNode> TypedRichNode<Array>::getElementsArray() {
+StaticArray<mozart::UnstableNode> TypedRichNode<Array>::getElementsArray() {
   return _self.access<Array>().getElementsArray();
 }
 
-class mozart::UnstableNode& TypedRichNode<Array>::getElements(size_t i) {
+mozart::UnstableNode& TypedRichNode<Array>::getElements(size_t i) {
   return _self.access<Array>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Array>::home() {
+mozart::Space *  TypedRichNode<Array>::home() {
   return _self.access<Array>().home();
 }
 
 inline
-bool  TypedRichNode<Array>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Array>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Array>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Array>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Array>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Array>().lookupFeature(vm, feature, value);
 }
 
@@ -71,56 +71,56 @@ size_t  TypedRichNode<Array>::getWidth() {
 }
 
 inline
-nativeint  TypedRichNode<Array>::getLow() {
+mozart::nativeint  TypedRichNode<Array>::getLow() {
   return _self.access<Array>().getLow();
 }
 
 inline
-nativeint  TypedRichNode<Array>::getHigh() {
+mozart::nativeint  TypedRichNode<Array>::getHigh() {
   return _self.access<Array>().getHigh();
 }
 
 inline
-void  TypedRichNode<Array>::dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+void  TypedRichNode<Array>::dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   _self.access<Array>().dotAssign(_self, vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Array>::dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   return _self.access<Array>().dotExchange(_self, vm, feature, newValue);
 }
 
 inline
-bool  TypedRichNode<Array>::isArray(VM vm) {
+bool  TypedRichNode<Array>::isArray(mozart::VM vm) {
   return _self.access<Array>().isArray(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayLow(VM vm) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayLow(mozart::VM vm) {
   return _self.access<Array>().arrayLow(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayHigh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayHigh(mozart::VM vm) {
   return _self.access<Array>().arrayHigh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayGet(VM vm, class mozart::RichNode index) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayGet(mozart::VM vm, mozart::RichNode index) {
   return _self.access<Array>().arrayGet(_self, vm, index);
 }
 
 inline
-void  TypedRichNode<Array>::arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value) {
+void  TypedRichNode<Array>::arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value) {
   _self.access<Array>().arrayPut(_self, vm, index, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue) {
   return _self.access<Array>().arrayExchange(_self, vm, index, newValue);
 }
 
 inline
-void  TypedRichNode<Array>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Array>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Array>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ArrayLike-interf.hh b/vm/boostenv/main/cached/ArrayLike-interf.hh
index 8cb1a58c8..ddc0c15e0 100644
--- a/vm/boostenv/main/cached/ArrayLike-interf.hh
+++ b/vm/boostenv/main/cached/ArrayLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ArrayLike(UnstableNode& self) : _self(self) {}
   ArrayLike(StableNode& self) : _self(self) {}
 
-  bool isArray(VM vm) {
+  bool isArray(mozart::VM vm) {
     if (_self.is<Array>()) {
       return _self.as<Array>().isArray(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayLow(VM vm) {
+  mozart::UnstableNode arrayLow(mozart::VM vm) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayLow(vm);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayLow", "arrayLow", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayHigh(VM vm) {
+  mozart::UnstableNode arrayHigh(mozart::VM vm) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayHigh(vm);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayHigh", "arrayHigh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayGet(VM vm, class mozart::RichNode index) {
+  mozart::UnstableNode arrayGet(mozart::VM vm, mozart::RichNode index) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayGet(vm, index);
     } else if (_self.isTransient()) {
@@ -60,7 +60,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayGet", "arrayGet", index, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -68,7 +68,7 @@ public:
     }
   }
 
-  void arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value) {
+  void arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayPut(vm, index, value);
     } else if (_self.isTransient()) {
@@ -83,7 +83,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue) {
+  mozart::UnstableNode arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayExchange(vm, index, newValue);
     } else if (_self.isTransient()) {
@@ -91,7 +91,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayExchange", "arrayExchange", index, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/Atom-implem-decl-after.hh b/vm/boostenv/main/cached/Atom-implem-decl-after.hh
index e23cdf9da..eb584aed1 100644
--- a/vm/boostenv/main/cached/Atom-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Atom-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<Atom>: public TypeInfo {
     return Atom::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("Atom", uuid(), (! ::mozart::MemWord::requiresExternalMemory<atom_t>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("Atom", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::atom_t>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<Atom>* const instance() {
     return &RawType<Atom>::rawType;
@@ -45,62 +45,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  atom_t value();
+  mozart::atom_t value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isAtom(VM vm);
+  bool isAtom(mozart::VM vm);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Atom-implem-decl.hh b/vm/boostenv/main/cached/Atom-implem-decl.hh
index 6d1f61198..fb03ec7ab 100644
--- a/vm/boostenv/main/cached/Atom-implem-decl.hh
+++ b/vm/boostenv/main/cached/Atom-implem-decl.hh
@@ -3,5 +3,5 @@ class Atom;
 template <>
 class Storage<Atom> {
 public:
-  typedef atom_t Type;
+  typedef mozart::atom_t Type;
 };
diff --git a/vm/boostenv/main/cached/Atom-implem.hh b/vm/boostenv/main/cached/Atom-implem.hh
index 9a0fe772e..bbcbed493 100644
--- a/vm/boostenv/main/cached/Atom-implem.hh
+++ b/vm/boostenv/main/cached/Atom-implem.hh
@@ -31,101 +31,101 @@ int TypeInfoOf<Atom>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) const {
 
 
 inline
-bool  TypedRichNode<Atom>::isLiteral(VM vm) {
+bool  TypedRichNode<Atom>::isLiteral(mozart::VM vm) {
   return _self.access<Atom>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Atom>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Atom>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Atom>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Atom>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Atom>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Atom>::isRecord(VM vm) {
+bool  TypedRichNode<Atom>::isRecord(mozart::VM vm) {
   return _self.access<Atom>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::isTuple(VM vm) {
+bool  TypedRichNode<Atom>::isTuple(mozart::VM vm) {
   return _self.access<Atom>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::label(mozart::VM vm) {
   return _self.access<Atom>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<Atom>::width(VM vm) {
+size_t  TypedRichNode<Atom>::width(mozart::VM vm) {
   return _self.access<Atom>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::arityList(mozart::VM vm) {
   return _self.access<Atom>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::clone(mozart::VM vm) {
   return _self.access<Atom>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::waitOr(mozart::VM vm) {
   return _self.access<Atom>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Atom>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Atom>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Atom>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Atom>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Atom>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Atom>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Atom>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Atom>().testLabel(_self, vm, label);
 }
 
 inline
-atom_t  TypedRichNode<Atom>::value() {
+mozart::atom_t  TypedRichNode<Atom>::value() {
   return _self.access<Atom>().value();
 }
 
 inline
-bool  TypedRichNode<Atom>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Atom>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Atom>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Atom>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Atom>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Atom>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<Atom>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Atom>::getPrintName(mozart::VM vm) {
   return _self.access<Atom>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::isAtom(VM vm) {
+bool  TypedRichNode<Atom>::isAtom(mozart::VM vm) {
   return _self.access<Atom>().isAtom(vm);
 }
 
 inline
-int  TypedRichNode<Atom>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Atom>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Atom>().compare(vm, right);
 }
 
 inline
-void  TypedRichNode<Atom>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Atom>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Atom>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/AtomLike-interf.hh b/vm/boostenv/main/cached/AtomLike-interf.hh
index 9dc552154..a5fbfd797 100644
--- a/vm/boostenv/main/cached/AtomLike-interf.hh
+++ b/vm/boostenv/main/cached/AtomLike-interf.hh
@@ -4,7 +4,7 @@ public:
   AtomLike(UnstableNode& self) : _self(self) {}
   AtomLike(StableNode& self) : _self(self) {}
 
-  bool isAtom(VM vm) {
+  bool isAtom(mozart::VM vm) {
     if (_self.is<Atom>()) {
       return _self.as<Atom>().isAtom(vm);
     } else if (_self.isTransient()) {
diff --git a/vm/boostenv/main/cached/BaseDottable-interf.hh b/vm/boostenv/main/cached/BaseDottable-interf.hh
index 1fa125a11..ae2ab6e88 100644
--- a/vm/boostenv/main/cached/BaseDottable-interf.hh
+++ b/vm/boostenv/main/cached/BaseDottable-interf.hh
@@ -4,7 +4,7 @@ public:
   BaseDottable(UnstableNode& self) : _self(self) {}
   BaseDottable(StableNode& self) : _self(self) {}
 
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().lookupFeature(vm, feature, value);
     } else if (_self.is<Record>()) {
@@ -42,7 +42,7 @@ public:
     }
   }
 
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().lookupFeature(vm, feature, value);
     } else if (_self.is<Record>()) {
diff --git a/vm/boostenv/main/cached/BigInt-implem-decl-after.hh b/vm/boostenv/main/cached/BigInt-implem-decl-after.hh
index 88f966a71..c2be2e6da 100644
--- a/vm/boostenv/main/cached/BigInt-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/BigInt-implem-decl-after.hh
@@ -48,46 +48,46 @@ public:
   std::shared_ptr<BigIntImplem> value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isNumber(VM vm);
+  bool isNumber(mozart::VM vm);
 
   inline
-  bool isInt(VM vm);
+  bool isInt(mozart::VM vm);
 
   inline
-  bool isFloat(VM vm);
+  bool isFloat(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode opposite(VM vm);
+  mozart::UnstableNode opposite(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode add(VM vm, nativeint b);
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode abs(VM vm);
+  mozart::UnstableNode abs(mozart::VM vm);
 
   inline
   double doubleValue();
@@ -96,5 +96,5 @@ public:
   std::string str();
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/BigInt-implem.hh b/vm/boostenv/main/cached/BigInt-implem.hh
index 77be62db4..dd692c65a 100644
--- a/vm/boostenv/main/cached/BigInt-implem.hh
+++ b/vm/boostenv/main/cached/BigInt-implem.hh
@@ -36,72 +36,72 @@ std::shared_ptr<BigIntImplem>  TypedRichNode<BigInt>::value() {
 }
 
 inline
-bool  TypedRichNode<BigInt>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<BigInt>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<BigInt>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<BigInt>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().compareFeatures(vm, right);
 }
 
 inline
-int  TypedRichNode<BigInt>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<BigInt>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<BigInt>::isNumber(VM vm) {
+bool  TypedRichNode<BigInt>::isNumber(mozart::VM vm) {
   return _self.access<BigInt>().isNumber(vm);
 }
 
 inline
-bool  TypedRichNode<BigInt>::isInt(VM vm) {
+bool  TypedRichNode<BigInt>::isInt(mozart::VM vm) {
   return _self.access<BigInt>().isInt(vm);
 }
 
 inline
-bool  TypedRichNode<BigInt>::isFloat(VM vm) {
+bool  TypedRichNode<BigInt>::isFloat(mozart::VM vm) {
   return _self.access<BigInt>().isFloat(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::opposite(VM vm) {
+mozart::UnstableNode  TypedRichNode<BigInt>::opposite(mozart::VM vm) {
   return _self.access<BigInt>().opposite(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::add(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::add(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().add(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::add(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<BigInt>::add(mozart::VM vm, mozart::nativeint b) {
   return _self.access<BigInt>().add(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::subtract(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::subtract(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().subtract(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::multiply(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::multiply(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().multiply(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::div(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::div(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().div(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::mod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::mod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().mod(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::abs(VM vm) {
+mozart::UnstableNode  TypedRichNode<BigInt>::abs(mozart::VM vm) {
   return _self.access<BigInt>().abs(_self, vm);
 }
 
@@ -116,6 +116,6 @@ std::string  TypedRichNode<BigInt>::str() {
 }
 
 inline
-void  TypedRichNode<BigInt>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<BigInt>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<BigInt>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/BindableReadOnly-interf.hh b/vm/boostenv/main/cached/BindableReadOnly-interf.hh
index 7bfbff94b..c743f624f 100644
--- a/vm/boostenv/main/cached/BindableReadOnly-interf.hh
+++ b/vm/boostenv/main/cached/BindableReadOnly-interf.hh
@@ -4,7 +4,7 @@ public:
   BindableReadOnly(UnstableNode& self) : _self(self) {}
   BindableReadOnly(StableNode& self) : _self(self) {}
 
-  void bindReadOnly(VM vm, class mozart::RichNode src) {
+  void bindReadOnly(mozart::VM vm, mozart::RichNode src) {
     if (_self.is<ReadOnlyVariable>()) {
       return _self.as<ReadOnlyVariable>().bindReadOnly(vm, src);
     } else if (_self.is<ReflectiveVariable>()) {
diff --git a/vm/boostenv/main/cached/Boolean-implem-decl-after.hh b/vm/boostenv/main/cached/Boolean-implem-decl-after.hh
index da2839d89..00ae58fd4 100644
--- a/vm/boostenv/main/cached/Boolean-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Boolean-implem-decl-after.hh
@@ -48,62 +48,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
   bool value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Boolean-implem.hh b/vm/boostenv/main/cached/Boolean-implem.hh
index 049da9504..2bbba4002 100644
--- a/vm/boostenv/main/cached/Boolean-implem.hh
+++ b/vm/boostenv/main/cached/Boolean-implem.hh
@@ -36,67 +36,67 @@ int TypeInfoOf<Boolean>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) cons
 
 
 inline
-bool  TypedRichNode<Boolean>::isLiteral(VM vm) {
+bool  TypedRichNode<Boolean>::isLiteral(mozart::VM vm) {
   return _self.access<Boolean>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Boolean>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Boolean>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Boolean>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Boolean>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Boolean>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Boolean>::isRecord(VM vm) {
+bool  TypedRichNode<Boolean>::isRecord(mozart::VM vm) {
   return _self.access<Boolean>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::isTuple(VM vm) {
+bool  TypedRichNode<Boolean>::isTuple(mozart::VM vm) {
   return _self.access<Boolean>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::label(mozart::VM vm) {
   return _self.access<Boolean>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<Boolean>::width(VM vm) {
+size_t  TypedRichNode<Boolean>::width(mozart::VM vm) {
   return _self.access<Boolean>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::arityList(mozart::VM vm) {
   return _self.access<Boolean>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::clone(mozart::VM vm) {
   return _self.access<Boolean>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::waitOr(mozart::VM vm) {
   return _self.access<Boolean>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Boolean>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Boolean>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Boolean>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Boolean>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Boolean>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Boolean>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Boolean>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Boolean>().testLabel(_self, vm, label);
 }
 
@@ -106,31 +106,31 @@ bool  TypedRichNode<Boolean>::value() {
 }
 
 inline
-bool  TypedRichNode<Boolean>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Boolean>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Boolean>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Boolean>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Boolean>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Boolean>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<Boolean>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Boolean>::getPrintName(mozart::VM vm) {
   return _self.access<Boolean>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::isName(VM vm) {
+bool  TypedRichNode<Boolean>::isName(mozart::VM vm) {
   return _self.access<Boolean>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Boolean>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Boolean>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<Boolean>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Boolean>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Boolean>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/BuiltinCallable-interf.hh b/vm/boostenv/main/cached/BuiltinCallable-interf.hh
index 6de15bc8b..a74f5b166 100644
--- a/vm/boostenv/main/cached/BuiltinCallable-interf.hh
+++ b/vm/boostenv/main/cached/BuiltinCallable-interf.hh
@@ -4,7 +4,7 @@ public:
   BuiltinCallable(UnstableNode& self) : _self(self) {}
   BuiltinCallable(StableNode& self) : _self(self) {}
 
-  bool isBuiltin(VM vm) {
+  bool isBuiltin(mozart::VM vm) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().isBuiltin(vm);
     } else if (_self.isTransient()) {
@@ -15,7 +15,7 @@ public:
     }
   }
 
-  void callBuiltin(VM vm, size_t argc, class mozart::UnstableNode ** args) {
+  void callBuiltin(mozart::VM vm, size_t argc, mozart::UnstableNode ** args) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().callBuiltin(vm, argc, args);
     } else if (_self.isTransient()) {
@@ -27,7 +27,7 @@ public:
   }
 
   template <class ... Args> 
-  void callBuiltin(VM vm, Args &&... args) {
+  void callBuiltin(mozart::VM vm, Args &&... args) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().callBuiltin(vm, std::forward<Args>(args)...);
     } else if (_self.isTransient()) {
@@ -38,7 +38,7 @@ public:
     }
   }
 
-  builtins::BaseBuiltin * getBuiltin(VM vm) {
+  builtins::BaseBuiltin * getBuiltin(mozart::VM vm) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().getBuiltin(vm);
     } else if (_self.isTransient()) {
diff --git a/vm/boostenv/main/cached/BuiltinProcedure-implem-decl-after.hh b/vm/boostenv/main/cached/BuiltinProcedure-implem-decl-after.hh
index b662bedfb..d34235333 100644
--- a/vm/boostenv/main/cached/BuiltinProcedure-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/BuiltinProcedure-implem-decl-after.hh
@@ -51,42 +51,42 @@ public:
   size_t getArity();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isBuiltin(VM vm);
+  bool isBuiltin(mozart::VM vm);
 
   inline
-  void callBuiltin(VM vm, size_t argc, class mozart::UnstableNode ** args);
+  void callBuiltin(mozart::VM vm, size_t argc, mozart::UnstableNode ** args);
 
   template <class ... Args> 
   inline
-  void callBuiltin(VM vm, Args &&... args);
+  void callBuiltin(mozart::VM vm, Args &&... args);
 
   inline
-  builtins::BaseBuiltin * getBuiltin(VM vm);
+  builtins::BaseBuiltin * getBuiltin(mozart::VM vm);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/BuiltinProcedure-implem.hh b/vm/boostenv/main/cached/BuiltinProcedure-implem.hh
index 83160da7c..8dd2dbc83 100644
--- a/vm/boostenv/main/cached/BuiltinProcedure-implem.hh
+++ b/vm/boostenv/main/cached/BuiltinProcedure-implem.hh
@@ -41,67 +41,67 @@ size_t  TypedRichNode<BuiltinProcedure>::getArity() {
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<BuiltinProcedure>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BuiltinProcedure>().equals(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<BuiltinProcedure>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<BuiltinProcedure>::getPrintName(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::isBuiltin(VM vm) {
+bool  TypedRichNode<BuiltinProcedure>::isBuiltin(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().isBuiltin(vm);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::callBuiltin(VM vm, size_t argc, class mozart::UnstableNode ** args) {
+void  TypedRichNode<BuiltinProcedure>::callBuiltin(mozart::VM vm, size_t argc, mozart::UnstableNode ** args) {
   _self.access<BuiltinProcedure>().callBuiltin(vm, argc, args);
 }
 
 template <class ... Args> 
 inline
-void  TypedRichNode<BuiltinProcedure>::callBuiltin(VM vm, Args &&... args) {
+void  TypedRichNode<BuiltinProcedure>::callBuiltin(mozart::VM vm, Args &&... args) {
   _self.access<BuiltinProcedure>().callBuiltin<Args... >(vm, std::forward<Args>(args)...);
 }
 
 inline
-builtins::BaseBuiltin *  TypedRichNode<BuiltinProcedure>::getBuiltin(VM vm) {
+builtins::BaseBuiltin *  TypedRichNode<BuiltinProcedure>::getBuiltin(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().getBuiltin(vm);
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::isCallable(VM vm) {
+bool  TypedRichNode<BuiltinProcedure>::isCallable(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::isProcedure(VM vm) {
+bool  TypedRichNode<BuiltinProcedure>::isProcedure(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<BuiltinProcedure>::procedureArity(VM vm) {
+size_t  TypedRichNode<BuiltinProcedure>::procedureArity(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().procedureArity(vm);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<BuiltinProcedure>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<BuiltinProcedure>().getCallInfo(_self, vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<BuiltinProcedure>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<BuiltinProcedure>().getDebugInfo(_self, vm, printName, debugData);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BuiltinProcedure>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<BuiltinProcedure>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<BuiltinProcedure>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<BuiltinProcedure>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<BuiltinProcedure>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ByteString-implem-decl-after.hh b/vm/boostenv/main/cached/ByteString-implem-decl-after.hh
index b757fefb6..0ca48851e 100644
--- a/vm/boostenv/main/cached/ByteString-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ByteString-implem-decl-after.hh
@@ -42,50 +42,50 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
   const LString<unsigned char> & value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isString(VM vm);
+  bool isString(mozart::VM vm);
 
   inline
-  bool isByteString(VM vm);
+  bool isByteString(mozart::VM vm);
 
   inline
-  LString<char> * stringGet(VM vm);
+  LString<char> * stringGet(mozart::VM vm);
 
   inline
-  LString<unsigned char> * byteStringGet(VM vm);
+  LString<unsigned char> * byteStringGet(mozart::VM vm);
 
   inline
-  nativeint stringCharAt(VM vm, class mozart::RichNode offset);
+  mozart::nativeint stringCharAt(mozart::VM vm, mozart::RichNode offset);
 
   inline
-  class mozart::UnstableNode stringAppend(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode stringAppend(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to);
+  mozart::UnstableNode stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to);
 
   inline
-  void stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end);
+  void stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end);
 
   inline
-  bool stringHasPrefix(VM vm, class mozart::RichNode prefix);
+  bool stringHasPrefix(mozart::VM vm, mozart::RichNode prefix);
 
   inline
-  bool stringHasSuffix(VM vm, class mozart::RichNode suffix);
+  bool stringHasSuffix(mozart::VM vm, mozart::RichNode suffix);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/ByteString-implem.hh b/vm/boostenv/main/cached/ByteString-implem.hh
index 167ec8b38..eab291308 100644
--- a/vm/boostenv/main/cached/ByteString-implem.hh
+++ b/vm/boostenv/main/cached/ByteString-implem.hh
@@ -26,12 +26,12 @@ void TypeInfoOf<ByteString>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-bool  TypedRichNode<ByteString>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<ByteString>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<ByteString>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<ByteString>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<ByteString>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<ByteString>().lookupFeature(vm, feature, value);
 }
 
@@ -41,66 +41,66 @@ const LString<unsigned char> &  TypedRichNode<ByteString>::value() {
 }
 
 inline
-bool  TypedRichNode<ByteString>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<ByteString>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ByteString>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<ByteString>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<ByteString>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ByteString>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<ByteString>::isString(VM vm) {
+bool  TypedRichNode<ByteString>::isString(mozart::VM vm) {
   return _self.access<ByteString>().isString(vm);
 }
 
 inline
-bool  TypedRichNode<ByteString>::isByteString(VM vm) {
+bool  TypedRichNode<ByteString>::isByteString(mozart::VM vm) {
   return _self.access<ByteString>().isByteString(vm);
 }
 
 inline
-LString<char> *  TypedRichNode<ByteString>::stringGet(VM vm) {
+LString<char> *  TypedRichNode<ByteString>::stringGet(mozart::VM vm) {
   return _self.access<ByteString>().stringGet(_self, vm);
 }
 
 inline
-LString<unsigned char> *  TypedRichNode<ByteString>::byteStringGet(VM vm) {
+LString<unsigned char> *  TypedRichNode<ByteString>::byteStringGet(mozart::VM vm) {
   return _self.access<ByteString>().byteStringGet(vm);
 }
 
 inline
-nativeint  TypedRichNode<ByteString>::stringCharAt(VM vm, class mozart::RichNode offset) {
+mozart::nativeint  TypedRichNode<ByteString>::stringCharAt(mozart::VM vm, mozart::RichNode offset) {
   return _self.access<ByteString>().stringCharAt(_self, vm, offset);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ByteString>::stringAppend(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<ByteString>::stringAppend(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ByteString>().stringAppend(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ByteString>::stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to) {
+mozart::UnstableNode  TypedRichNode<ByteString>::stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to) {
   return _self.access<ByteString>().stringSlice(_self, vm, from, to);
 }
 
 inline
-void  TypedRichNode<ByteString>::stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end) {
+void  TypedRichNode<ByteString>::stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end) {
   _self.access<ByteString>().stringSearch(_self, vm, from, needle, begin, end);
 }
 
 inline
-bool  TypedRichNode<ByteString>::stringHasPrefix(VM vm, class mozart::RichNode prefix) {
+bool  TypedRichNode<ByteString>::stringHasPrefix(mozart::VM vm, mozart::RichNode prefix) {
   return _self.access<ByteString>().stringHasPrefix(vm, prefix);
 }
 
 inline
-bool  TypedRichNode<ByteString>::stringHasSuffix(VM vm, class mozart::RichNode suffix) {
+bool  TypedRichNode<ByteString>::stringHasSuffix(mozart::VM vm, mozart::RichNode suffix) {
   return _self.access<ByteString>().stringHasSuffix(vm, suffix);
 }
 
 inline
-void  TypedRichNode<ByteString>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ByteString>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ByteString>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Callable-interf.hh b/vm/boostenv/main/cached/Callable-interf.hh
index accdfc6fd..77cc77ce1 100644
--- a/vm/boostenv/main/cached/Callable-interf.hh
+++ b/vm/boostenv/main/cached/Callable-interf.hh
@@ -4,7 +4,7 @@ public:
   Callable(UnstableNode& self) : _self(self) {}
   Callable(StableNode& self) : _self(self) {}
 
-  bool isCallable(VM vm) {
+  bool isCallable(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().isCallable(vm);
     } else if (_self.is<Object>()) {
@@ -19,7 +19,7 @@ public:
     }
   }
 
-  bool isProcedure(VM vm) {
+  bool isProcedure(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().isProcedure(vm);
     } else if (_self.is<Object>()) {
@@ -34,7 +34,7 @@ public:
     }
   }
 
-  size_t procedureArity(VM vm) {
+  size_t procedureArity(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().procedureArity(vm);
     } else if (_self.is<Object>()) {
@@ -49,7 +49,7 @@ public:
     }
   }
 
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().getCallInfo(vm, arity, start, Xcount, Gs, Ks);
     } else if (_self.is<Object>()) {
@@ -64,7 +64,7 @@ public:
     }
   }
 
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().getDebugInfo(vm, printName, debugData);
     } else if (_self.is<Object>()) {
diff --git a/vm/boostenv/main/cached/Cell-implem-decl-after.hh b/vm/boostenv/main/cached/Cell-implem-decl-after.hh
index b808ef55c..680f9c4c5 100644
--- a/vm/boostenv/main/cached/Cell-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Cell-implem-decl-after.hh
@@ -42,20 +42,20 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isCell(VM vm);
+  bool isCell(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode exchange(VM vm, class mozart::RichNode newValue);
+  mozart::UnstableNode exchange(mozart::VM vm, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode access(VM vm);
+  mozart::UnstableNode access(mozart::VM vm);
 
   inline
-  void assign(VM vm, class mozart::RichNode newValue);
+  void assign(mozart::VM vm, mozart::RichNode newValue);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Cell-implem.hh b/vm/boostenv/main/cached/Cell-implem.hh
index 0ad5098ec..bb0291c91 100644
--- a/vm/boostenv/main/cached/Cell-implem.hh
+++ b/vm/boostenv/main/cached/Cell-implem.hh
@@ -34,31 +34,31 @@ void TypeInfoOf<Cell>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<Cell>::home() {
+mozart::Space *  TypedRichNode<Cell>::home() {
   return _self.access<Cell>().home();
 }
 
 inline
-bool  TypedRichNode<Cell>::isCell(VM vm) {
+bool  TypedRichNode<Cell>::isCell(mozart::VM vm) {
   return _self.access<Cell>().isCell(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cell>::exchange(VM vm, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Cell>::exchange(mozart::VM vm, mozart::RichNode newValue) {
   return _self.access<Cell>().exchange(vm, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cell>::access(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cell>::access(mozart::VM vm) {
   return _self.access<Cell>().access(vm);
 }
 
 inline
-void  TypedRichNode<Cell>::assign(VM vm, class mozart::RichNode newValue) {
+void  TypedRichNode<Cell>::assign(mozart::VM vm, mozart::RichNode newValue) {
   _self.access<Cell>().assign(vm, newValue);
 }
 
 inline
-void  TypedRichNode<Cell>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Cell>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Cell>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/CellLike-interf.hh b/vm/boostenv/main/cached/CellLike-interf.hh
index f4d12ee8d..9f25c74e7 100644
--- a/vm/boostenv/main/cached/CellLike-interf.hh
+++ b/vm/boostenv/main/cached/CellLike-interf.hh
@@ -4,7 +4,7 @@ public:
   CellLike(UnstableNode& self) : _self(self) {}
   CellLike(StableNode& self) : _self(self) {}
 
-  bool isCell(VM vm) {
+  bool isCell(mozart::VM vm) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().isCell(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode exchange(VM vm, class mozart::RichNode newValue) {
+  mozart::UnstableNode exchange(mozart::VM vm, mozart::RichNode newValue) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().exchange(vm, newValue);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::CellLike::exchange", "exchange", newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode access(VM vm) {
+  mozart::UnstableNode access(mozart::VM vm) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().access(vm);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::CellLike::access", "access", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  void assign(VM vm, class mozart::RichNode newValue) {
+  void assign(mozart::VM vm, mozart::RichNode newValue) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().assign(vm, newValue);
     } else if (_self.isTransient()) {
diff --git a/vm/boostenv/main/cached/Chunk-implem-decl-after.hh b/vm/boostenv/main/cached/Chunk-implem-decl-after.hh
index c77427ea4..31b86a485 100644
--- a/vm/boostenv/main/cached/Chunk-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Chunk-implem-decl-after.hh
@@ -45,20 +45,20 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isChunk(VM vm);
+  bool isChunk(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/Chunk-implem-decl.hh b/vm/boostenv/main/cached/Chunk-implem-decl.hh
index 13f291889..dfbf50345 100644
--- a/vm/boostenv/main/cached/Chunk-implem-decl.hh
+++ b/vm/boostenv/main/cached/Chunk-implem-decl.hh
@@ -3,5 +3,5 @@ class Chunk;
 template <>
 class Storage<Chunk> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/Chunk-implem.hh b/vm/boostenv/main/cached/Chunk-implem.hh
index 7e58f9250..2b38e0e46 100644
--- a/vm/boostenv/main/cached/Chunk-implem.hh
+++ b/vm/boostenv/main/cached/Chunk-implem.hh
@@ -17,9 +17,7 @@ void TypeInfoOf<Chunk>::gCollect(GC gc, RichNode from, StableNode& to) const {
 
 void TypeInfoOf<Chunk>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<Chunk>(gc->vm, gc, from.access<Chunk>());
+  to.make<Chunk>(gc->vm, gc, from.access<Chunk>());
 }
 
 void TypeInfoOf<Chunk>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -33,31 +31,31 @@ void TypeInfoOf<Chunk>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Chunk>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<Chunk>::getUnderlying() {
   return _self.access<Chunk>().getUnderlying();
 }
 
 inline
-bool  TypedRichNode<Chunk>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Chunk>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Chunk>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Chunk>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Chunk>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Chunk>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Chunk>::isChunk(VM vm) {
+bool  TypedRichNode<Chunk>::isChunk(mozart::VM vm) {
   return _self.access<Chunk>().isChunk(vm);
 }
 
 inline
-void  TypedRichNode<Chunk>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Chunk>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Chunk>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Chunk>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Chunk>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Chunk>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/ChunkLike-interf.hh b/vm/boostenv/main/cached/ChunkLike-interf.hh
index 4a35b6b74..daeae8abe 100644
--- a/vm/boostenv/main/cached/ChunkLike-interf.hh
+++ b/vm/boostenv/main/cached/ChunkLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ChunkLike(UnstableNode& self) : _self(self) {}
   ChunkLike(StableNode& self) : _self(self) {}
 
-  bool isChunk(VM vm) {
+  bool isChunk(mozart::VM vm) {
     if (_self.is<Chunk>()) {
       return _self.as<Chunk>().isChunk(vm);
     } else if (_self.is<Object>()) {
diff --git a/vm/boostenv/main/cached/CodeArea-implem-decl-after.hh b/vm/boostenv/main/cached/CodeArea-implem-decl-after.hh
index 21003cb6c..aa9c96cf6 100644
--- a/vm/boostenv/main/cached/CodeArea-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/CodeArea-implem-decl-after.hh
@@ -51,32 +51,32 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  bool isCodeAreaProvider(VM vm);
+  bool isCodeAreaProvider(mozart::VM vm);
 
   inline
-  void getCodeAreaInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Ks);
+  void getCodeAreaInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getCodeAreaDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getCodeAreaDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void setUUID(VM vm, const struct mozart::UUID & uuid);
+  void setUUID(mozart::VM vm, const mozart::UUID & uuid);
 };
diff --git a/vm/boostenv/main/cached/CodeArea-implem-decl.hh b/vm/boostenv/main/cached/CodeArea-implem-decl.hh
index a2ec4250d..22815fbed 100644
--- a/vm/boostenv/main/cached/CodeArea-implem-decl.hh
+++ b/vm/boostenv/main/cached/CodeArea-implem-decl.hh
@@ -3,5 +3,5 @@ class CodeArea;
 template <>
 class Storage<CodeArea> {
 public:
-  typedef ImplWithArray<CodeArea, class mozart::StableNode> Type;
+  typedef ImplWithArray<CodeArea, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/CodeArea-implem.hh b/vm/boostenv/main/cached/CodeArea-implem.hh
index bbe5d81ed..090c1d8a7 100644
--- a/vm/boostenv/main/cached/CodeArea-implem.hh
+++ b/vm/boostenv/main/cached/CodeArea-implem.hh
@@ -39,11 +39,11 @@ size_t TypedRichNode<CodeArea>::getArraySize() {
   return _self.access<CodeArea>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<CodeArea>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<CodeArea>::getElementsArray() {
   return _self.access<CodeArea>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<CodeArea>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<CodeArea>::getElements(size_t i) {
   return _self.access<CodeArea>().getElements(i);
 }
 
@@ -53,36 +53,36 @@ size_t  TypedRichNode<CodeArea>::getArraySizeImpl() {
 }
 
 inline
-bool  TypedRichNode<CodeArea>::isCodeAreaProvider(VM vm) {
+bool  TypedRichNode<CodeArea>::isCodeAreaProvider(mozart::VM vm) {
   return _self.access<CodeArea>().isCodeAreaProvider(vm);
 }
 
 inline
-void  TypedRichNode<CodeArea>::getCodeAreaInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<CodeArea>::getCodeAreaInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Ks) {
   _self.access<CodeArea>().getCodeAreaInfo(vm, arity, start, Xcount, Ks);
 }
 
 inline
-void  TypedRichNode<CodeArea>::getCodeAreaDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<CodeArea>::getCodeAreaDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<CodeArea>().getCodeAreaDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<CodeArea>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<CodeArea>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<CodeArea>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<CodeArea>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<CodeArea>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<CodeArea>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<CodeArea>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<CodeArea>::globalize(mozart::VM vm) {
   return _self.access<CodeArea>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<CodeArea>::setUUID(VM vm, const struct mozart::UUID & uuid) {
+void  TypedRichNode<CodeArea>::setUUID(mozart::VM vm, const mozart::UUID & uuid) {
   _self.access<CodeArea>().setUUID(_self, vm, uuid);
 }
diff --git a/vm/boostenv/main/cached/CodeAreaProvider-interf.hh b/vm/boostenv/main/cached/CodeAreaProvider-interf.hh
index b37b30ffc..80eef0fbd 100644
--- a/vm/boostenv/main/cached/CodeAreaProvider-interf.hh
+++ b/vm/boostenv/main/cached/CodeAreaProvider-interf.hh
@@ -4,7 +4,7 @@ public:
   CodeAreaProvider(UnstableNode& self) : _self(self) {}
   CodeAreaProvider(StableNode& self) : _self(self) {}
 
-  bool isCodeAreaProvider(VM vm) {
+  bool isCodeAreaProvider(mozart::VM vm) {
     if (_self.is<CodeArea>()) {
       return _self.as<CodeArea>().isCodeAreaProvider(vm);
     } else if (_self.isTransient()) {
@@ -15,7 +15,7 @@ public:
     }
   }
 
-  void getCodeAreaInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Ks) {
+  void getCodeAreaInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Ks) {
     if (_self.is<CodeArea>()) {
       return _self.as<CodeArea>().getCodeAreaInfo(vm, arity, start, Xcount, Ks);
     } else if (_self.isTransient()) {
@@ -26,7 +26,7 @@ public:
     }
   }
 
-  void getCodeAreaDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+  void getCodeAreaDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
     if (_self.is<CodeArea>()) {
       return _self.as<CodeArea>().getCodeAreaDebugInfo(vm, printName, debugData);
     } else if (_self.isTransient()) {
diff --git a/vm/boostenv/main/cached/Comparable-interf.hh b/vm/boostenv/main/cached/Comparable-interf.hh
index ce9900b92..e879840e6 100644
--- a/vm/boostenv/main/cached/Comparable-interf.hh
+++ b/vm/boostenv/main/cached/Comparable-interf.hh
@@ -4,7 +4,7 @@ public:
   Comparable(UnstableNode& self) : _self(self) {}
   Comparable(StableNode& self) : _self(self) {}
 
-  int compare(VM vm, class mozart::RichNode right) {
+  int compare(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().compare(vm, right);
     } else if (_self.is<BigInt>()) {
diff --git a/vm/boostenv/main/cached/Cons-implem-decl-after.hh b/vm/boostenv/main/cached/Cons-implem-decl-after.hh
index a0509c35d..d808eda65 100644
--- a/vm/boostenv/main/cached/Cons-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Cons-implem-decl-after.hh
@@ -45,59 +45,59 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  class mozart::StableNode * getHead();
+  mozart::StableNode * getHead();
 
   inline
-  class mozart::StableNode * getTail();
+  mozart::StableNode * getTail();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  bool hasListRepr(VM vm, int depth);
+  bool hasListRepr(mozart::VM vm, int depth);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/Cons-implem.hh b/vm/boostenv/main/cached/Cons-implem.hh
index 6eaf7bf15..e331edd33 100644
--- a/vm/boostenv/main/cached/Cons-implem.hh
+++ b/vm/boostenv/main/cached/Cons-implem.hh
@@ -31,96 +31,96 @@ void TypeInfoOf<Cons>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-bool  TypedRichNode<Cons>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Cons>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Cons>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Cons>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Cons>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Cons>().lookupFeature(vm, feature, value);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Cons>::getHead() {
+mozart::StableNode *  TypedRichNode<Cons>::getHead() {
   return _self.access<Cons>().getHead();
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Cons>::getTail() {
+mozart::StableNode *  TypedRichNode<Cons>::getTail() {
   return _self.access<Cons>().getTail();
 }
 
 inline
-StaticArray<class mozart::StableNode>  TypedRichNode<Cons>::getElementsArray() {
+StaticArray<mozart::StableNode>  TypedRichNode<Cons>::getElementsArray() {
   return _self.access<Cons>().getElementsArray();
 }
 
 inline
-bool  TypedRichNode<Cons>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Cons>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Cons>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Cons>::isRecord(VM vm) {
+bool  TypedRichNode<Cons>::isRecord(mozart::VM vm) {
   return _self.access<Cons>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Cons>::isTuple(VM vm) {
+bool  TypedRichNode<Cons>::isTuple(mozart::VM vm) {
   return _self.access<Cons>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::label(mozart::VM vm) {
   return _self.access<Cons>().label(vm);
 }
 
 inline
-size_t  TypedRichNode<Cons>::width(VM vm) {
+size_t  TypedRichNode<Cons>::width(mozart::VM vm) {
   return _self.access<Cons>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::arityList(mozart::VM vm) {
   return _self.access<Cons>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::clone(mozart::VM vm) {
   return _self.access<Cons>().clone(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::waitOr(mozart::VM vm) {
   return _self.access<Cons>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Cons>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Cons>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Cons>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Cons>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Cons>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Cons>().testTuple(vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Cons>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Cons>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Cons>().testLabel(vm, label);
 }
 
 inline
-void  TypedRichNode<Cons>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Cons>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Cons>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-bool  TypedRichNode<Cons>::hasListRepr(VM vm, int depth) {
+bool  TypedRichNode<Cons>::hasListRepr(mozart::VM vm, int depth) {
   return _self.access<Cons>().hasListRepr(vm, depth);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Cons>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Cons>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/DataflowVariable-interf.hh b/vm/boostenv/main/cached/DataflowVariable-interf.hh
index 2f57cd7d1..1cf5935e1 100644
--- a/vm/boostenv/main/cached/DataflowVariable-interf.hh
+++ b/vm/boostenv/main/cached/DataflowVariable-interf.hh
@@ -4,7 +4,7 @@ public:
   DataflowVariable(UnstableNode& self) : _self(self) {}
   DataflowVariable(StableNode& self) : _self(self) {}
 
-  void addToSuspendList(VM vm, class mozart::RichNode variable) {
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().addToSuspendList(vm, variable);
     } else if (_self.is<Variable>()) {
@@ -22,7 +22,7 @@ public:
     }
   }
 
-  bool isNeeded(VM vm) {
+  bool isNeeded(mozart::VM vm) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().isNeeded(vm);
     } else if (_self.is<Variable>()) {
@@ -40,7 +40,7 @@ public:
     }
   }
 
-  void markNeeded(VM vm) {
+  void markNeeded(mozart::VM vm) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().markNeeded(vm);
     } else if (_self.is<Variable>()) {
@@ -58,7 +58,7 @@ public:
     }
   }
 
-  void bind(VM vm, class mozart::RichNode src) {
+  void bind(mozart::VM vm, mozart::RichNode src) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().bind(vm, src);
     } else if (_self.is<Variable>()) {
diff --git a/vm/boostenv/main/cached/Dictionary-implem-decl-after.hh b/vm/boostenv/main/cached/Dictionary-implem-decl-after.hh
index 7755836e0..9a7a60e0f 100644
--- a/vm/boostenv/main/cached/Dictionary-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Dictionary-implem-decl-after.hh
@@ -42,65 +42,65 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  bool isDictionary(VM vm);
+  bool isDictionary(mozart::VM vm);
 
   inline
-  bool dictIsEmpty(VM vm);
+  bool dictIsEmpty(mozart::VM vm);
 
   inline
-  bool dictMember(VM vm, class mozart::RichNode feature);
+  bool dictMember(mozart::VM vm, mozart::RichNode feature);
 
   inline
-  class mozart::UnstableNode dictGet(VM vm, class mozart::RichNode feature);
+  mozart::UnstableNode dictGet(mozart::VM vm, mozart::RichNode feature);
 
   inline
-  class mozart::UnstableNode dictCondGet(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue);
+  mozart::UnstableNode dictCondGet(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue);
 
   inline
-  void dictPut(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dictPut(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dictExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dictExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dictCondExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue, class mozart::RichNode newValue);
+  mozart::UnstableNode dictCondExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue, mozart::RichNode newValue);
 
   inline
-  void dictRemove(VM vm, class mozart::RichNode feature);
+  void dictRemove(mozart::VM vm, mozart::RichNode feature);
 
   inline
-  void dictRemoveAll(VM vm);
+  void dictRemoveAll(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictKeys(VM vm);
+  mozart::UnstableNode dictKeys(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictEntries(VM vm);
+  mozart::UnstableNode dictEntries(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictItems(VM vm);
+  mozart::UnstableNode dictItems(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictClone(VM vm);
+  mozart::UnstableNode dictClone(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::NodeDictionary & getDict();
+  mozart::NodeDictionary & getDict();
 };
diff --git a/vm/boostenv/main/cached/Dictionary-implem.hh b/vm/boostenv/main/cached/Dictionary-implem.hh
index 05d4513b9..5641b7c8f 100644
--- a/vm/boostenv/main/cached/Dictionary-implem.hh
+++ b/vm/boostenv/main/cached/Dictionary-implem.hh
@@ -34,106 +34,106 @@ void TypeInfoOf<Dictionary>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-class mozart::Space *  TypedRichNode<Dictionary>::home() {
+mozart::Space *  TypedRichNode<Dictionary>::home() {
   return _self.access<Dictionary>().home();
 }
 
 inline
-bool  TypedRichNode<Dictionary>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Dictionary>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Dictionary>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Dictionary>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Dictionary>().lookupFeature(vm, feature, value);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+void  TypedRichNode<Dictionary>::dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   _self.access<Dictionary>().dotAssign(vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   return _self.access<Dictionary>().dotExchange(_self, vm, feature, newValue);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::isDictionary(VM vm) {
+bool  TypedRichNode<Dictionary>::isDictionary(mozart::VM vm) {
   return _self.access<Dictionary>().isDictionary(vm);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::dictIsEmpty(VM vm) {
+bool  TypedRichNode<Dictionary>::dictIsEmpty(mozart::VM vm) {
   return _self.access<Dictionary>().dictIsEmpty(vm);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::dictMember(VM vm, class mozart::RichNode feature) {
+bool  TypedRichNode<Dictionary>::dictMember(mozart::VM vm, mozart::RichNode feature) {
   return _self.access<Dictionary>().dictMember(vm, feature);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictGet(VM vm, class mozart::RichNode feature) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictGet(mozart::VM vm, mozart::RichNode feature) {
   return _self.access<Dictionary>().dictGet(_self, vm, feature);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondGet(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondGet(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue) {
   return _self.access<Dictionary>().dictCondGet(vm, feature, defaultValue);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dictPut(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+void  TypedRichNode<Dictionary>::dictPut(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   _self.access<Dictionary>().dictPut(vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   return _self.access<Dictionary>().dictExchange(_self, vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue, mozart::RichNode newValue) {
   return _self.access<Dictionary>().dictCondExchange(vm, feature, defaultValue, newValue);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dictRemove(VM vm, class mozart::RichNode feature) {
+void  TypedRichNode<Dictionary>::dictRemove(mozart::VM vm, mozart::RichNode feature) {
   _self.access<Dictionary>().dictRemove(vm, feature);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dictRemoveAll(VM vm) {
+void  TypedRichNode<Dictionary>::dictRemoveAll(mozart::VM vm) {
   _self.access<Dictionary>().dictRemoveAll(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictKeys(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictKeys(mozart::VM vm) {
   return _self.access<Dictionary>().dictKeys(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictEntries(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictEntries(mozart::VM vm) {
   return _self.access<Dictionary>().dictEntries(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictItems(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictItems(mozart::VM vm) {
   return _self.access<Dictionary>().dictItems(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictClone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictClone(mozart::VM vm) {
   return _self.access<Dictionary>().dictClone(vm);
 }
 
 inline
-void  TypedRichNode<Dictionary>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Dictionary>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Dictionary>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::NodeDictionary &  TypedRichNode<Dictionary>::getDict() {
+mozart::NodeDictionary &  TypedRichNode<Dictionary>::getDict() {
   return _self.access<Dictionary>().getDict();
 }
diff --git a/vm/boostenv/main/cached/DictionaryLike-interf.hh b/vm/boostenv/main/cached/DictionaryLike-interf.hh
index 06fc94d0f..f5538659b 100644
--- a/vm/boostenv/main/cached/DictionaryLike-interf.hh
+++ b/vm/boostenv/main/cached/DictionaryLike-interf.hh
@@ -4,7 +4,7 @@ public:
   DictionaryLike(UnstableNode& self) : _self(self) {}
   DictionaryLike(StableNode& self) : _self(self) {}
 
-  bool isDictionary(VM vm) {
+  bool isDictionary(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().isDictionary(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  bool dictIsEmpty(VM vm) {
+  bool dictIsEmpty(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictIsEmpty(vm);
     } else if (_self.isTransient()) {
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  bool dictMember(VM vm, class mozart::RichNode feature) {
+  bool dictMember(mozart::VM vm, mozart::RichNode feature) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictMember(vm, feature);
     } else if (_self.isTransient()) {
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictGet(VM vm, class mozart::RichNode feature) {
+  mozart::UnstableNode dictGet(mozart::VM vm, mozart::RichNode feature) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictGet(vm, feature);
     } else if (_self.isTransient()) {
@@ -60,7 +60,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictGet", "dictGet", feature, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -68,7 +68,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictCondGet(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue) {
+  mozart::UnstableNode dictCondGet(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictCondGet(vm, feature, defaultValue);
     } else if (_self.isTransient()) {
@@ -76,7 +76,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictCondGet", "dictCondGet", feature, defaultValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -84,7 +84,7 @@ public:
     }
   }
 
-  void dictPut(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  void dictPut(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictPut(vm, feature, newValue);
     } else if (_self.isTransient()) {
@@ -99,7 +99,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  mozart::UnstableNode dictExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictExchange(vm, feature, newValue);
     } else if (_self.isTransient()) {
@@ -107,7 +107,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictExchange", "dictExchange", feature, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -115,7 +115,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictCondExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue, class mozart::RichNode newValue) {
+  mozart::UnstableNode dictCondExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue, mozart::RichNode newValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictCondExchange(vm, feature, defaultValue, newValue);
     } else if (_self.isTransient()) {
@@ -123,7 +123,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictCondExchange", "dictCondExchange", feature, defaultValue, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -131,7 +131,7 @@ public:
     }
   }
 
-  void dictRemove(VM vm, class mozart::RichNode feature) {
+  void dictRemove(mozart::VM vm, mozart::RichNode feature) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictRemove(vm, feature);
     } else if (_self.isTransient()) {
@@ -146,7 +146,7 @@ public:
     }
   }
 
-  void dictRemoveAll(VM vm) {
+  void dictRemoveAll(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictRemoveAll(vm);
     } else if (_self.isTransient()) {
@@ -161,7 +161,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictKeys(VM vm) {
+  mozart::UnstableNode dictKeys(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictKeys(vm);
     } else if (_self.isTransient()) {
@@ -169,7 +169,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictKeys", "dictKeys", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -177,7 +177,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictEntries(VM vm) {
+  mozart::UnstableNode dictEntries(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictEntries(vm);
     } else if (_self.isTransient()) {
@@ -185,7 +185,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictEntries", "dictEntries", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -193,7 +193,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictItems(VM vm) {
+  mozart::UnstableNode dictItems(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictItems(vm);
     } else if (_self.isTransient()) {
@@ -201,7 +201,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictItems", "dictItems", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -209,7 +209,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictClone(VM vm) {
+  mozart::UnstableNode dictClone(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictClone(vm);
     } else if (_self.isTransient()) {
@@ -217,7 +217,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictClone", "dictClone", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/DotAssignable-interf.hh b/vm/boostenv/main/cached/DotAssignable-interf.hh
index 66ae750a6..c5a41bc7c 100644
--- a/vm/boostenv/main/cached/DotAssignable-interf.hh
+++ b/vm/boostenv/main/cached/DotAssignable-interf.hh
@@ -4,7 +4,7 @@ public:
   DotAssignable(UnstableNode& self) : _self(self) {}
   DotAssignable(StableNode& self) : _self(self) {}
 
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Array>()) {
       return _self.as<Array>().dotAssign(vm, feature, newValue);
     } else if (_self.is<Dictionary>()) {
@@ -21,7 +21,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Array>()) {
       return _self.as<Array>().dotExchange(vm, feature, newValue);
     } else if (_self.is<Dictionary>()) {
@@ -31,7 +31,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DotAssignable::dotExchange", "dotExchange", feature, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/FailedSpace-implem-decl-after.hh b/vm/boostenv/main/cached/FailedSpace-implem-decl-after.hh
index 135b1978f..1be98382a 100644
--- a/vm/boostenv/main/cached/FailedSpace-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/FailedSpace-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isSpace(VM vm);
+  bool isSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askSpace(VM vm);
+  mozart::UnstableNode askSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askVerboseSpace(VM vm);
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode mergeSpace(VM vm);
+  mozart::UnstableNode mergeSpace(mozart::VM vm);
 
   inline
-  void commitSpace(VM vm, class mozart::RichNode value);
+  void commitSpace(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode cloneSpace(VM vm);
+  mozart::UnstableNode cloneSpace(mozart::VM vm);
 
   inline
-  void killSpace(VM vm);
+  void killSpace(mozart::VM vm);
 };
diff --git a/vm/boostenv/main/cached/FailedSpace-implem-decl.hh b/vm/boostenv/main/cached/FailedSpace-implem-decl.hh
index 331ad0949..ca053fd9e 100644
--- a/vm/boostenv/main/cached/FailedSpace-implem-decl.hh
+++ b/vm/boostenv/main/cached/FailedSpace-implem-decl.hh
@@ -3,5 +3,5 @@ class FailedSpace;
 template <>
 class Storage<FailedSpace> {
 public:
-  typedef struct mozart::unit_t Type;
+  typedef mozart::unit_t Type;
 };
diff --git a/vm/boostenv/main/cached/FailedSpace-implem.hh b/vm/boostenv/main/cached/FailedSpace-implem.hh
index 0c00900b9..588ef9457 100644
--- a/vm/boostenv/main/cached/FailedSpace-implem.hh
+++ b/vm/boostenv/main/cached/FailedSpace-implem.hh
@@ -20,36 +20,36 @@ void TypeInfoOf<FailedSpace>::sClone(SC sc, RichNode from, UnstableNode& to) con
 }
 
 inline
-bool  TypedRichNode<FailedSpace>::isSpace(VM vm) {
+bool  TypedRichNode<FailedSpace>::isSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().isSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::askSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::askSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().askSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::askVerboseSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::askVerboseSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().askVerboseSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::mergeSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::mergeSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().mergeSpace(vm);
 }
 
 inline
-void  TypedRichNode<FailedSpace>::commitSpace(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<FailedSpace>::commitSpace(mozart::VM vm, mozart::RichNode value) {
   _self.access<FailedSpace>().commitSpace(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::cloneSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::cloneSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().cloneSpace(vm);
 }
 
 inline
-void  TypedRichNode<FailedSpace>::killSpace(VM vm) {
+void  TypedRichNode<FailedSpace>::killSpace(mozart::VM vm) {
   _self.access<FailedSpace>().killSpace(vm);
 }
diff --git a/vm/boostenv/main/cached/FailedValue-implem-decl-after.hh b/vm/boostenv/main/cached/FailedValue-implem-decl-after.hh
index 0653a8f01..6e3ab4033 100644
--- a/vm/boostenv/main/cached/FailedValue-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/FailedValue-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 
   inline
-  void raiseUnderlying(VM vm);
+  void raiseUnderlying(mozart::VM vm);
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/FailedValue-implem-decl.hh b/vm/boostenv/main/cached/FailedValue-implem-decl.hh
index 0b8df9f7a..2117d2b9f 100644
--- a/vm/boostenv/main/cached/FailedValue-implem-decl.hh
+++ b/vm/boostenv/main/cached/FailedValue-implem-decl.hh
@@ -3,5 +3,5 @@ class FailedValue;
 template <>
 class Storage<FailedValue> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/FailedValue-implem.hh b/vm/boostenv/main/cached/FailedValue-implem.hh
index f23db8fd5..e71befc2f 100644
--- a/vm/boostenv/main/cached/FailedValue-implem.hh
+++ b/vm/boostenv/main/cached/FailedValue-implem.hh
@@ -12,9 +12,7 @@ void TypeInfoOf<FailedValue>::gCollect(GC gc, RichNode from, StableNode& to) con
 
 void TypeInfoOf<FailedValue>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<FailedValue>(gc->vm, gc, from.access<FailedValue>());
+  to.make<FailedValue>(gc->vm, gc, from.access<FailedValue>());
 }
 
 void TypeInfoOf<FailedValue>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -28,36 +26,36 @@ void TypeInfoOf<FailedValue>::sClone(SC sc, RichNode from, UnstableNode& to) con
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<FailedValue>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<FailedValue>::getUnderlying() {
   return _self.access<FailedValue>().getUnderlying();
 }
 
 inline
-void  TypedRichNode<FailedValue>::raiseUnderlying(VM vm) {
+void  TypedRichNode<FailedValue>::raiseUnderlying(mozart::VM vm) {
   _self.access<FailedValue>().raiseUnderlying(vm);
 }
 
 inline
-void  TypedRichNode<FailedValue>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<FailedValue>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<FailedValue>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<FailedValue>::isNeeded(VM vm) {
+bool  TypedRichNode<FailedValue>::isNeeded(mozart::VM vm) {
   return _self.access<FailedValue>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<FailedValue>::markNeeded(VM vm) {
+void  TypedRichNode<FailedValue>::markNeeded(mozart::VM vm) {
   _self.access<FailedValue>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<FailedValue>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<FailedValue>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<FailedValue>().bind(vm, src);
 }
 
 inline
-void  TypedRichNode<FailedValue>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<FailedValue>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<FailedValue>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Float-implem-decl-after.hh b/vm/boostenv/main/cached/Float-implem-decl-after.hh
index 9a618418b..442e4bc86 100644
--- a/vm/boostenv/main/cached/Float-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Float-implem-decl-after.hh
@@ -45,131 +45,131 @@ public:
   double value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isNumber(VM vm);
+  bool isNumber(mozart::VM vm);
 
   inline
-  bool isInt(VM vm);
+  bool isInt(mozart::VM vm);
 
   inline
-  bool isFloat(VM vm);
+  bool isFloat(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode opposite(VM vm);
+  mozart::UnstableNode opposite(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode add(VM vm, nativeint right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint right);
 
   inline
-  class mozart::UnstableNode addValue(VM vm, double b);
+  mozart::UnstableNode addValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode subtractValue(VM vm, double b);
+  mozart::UnstableNode subtractValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode multiplyValue(VM vm, double b);
+  mozart::UnstableNode multiplyValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode divide(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode divide(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode divideValue(VM vm, double b);
+  mozart::UnstableNode divideValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode fmod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode fmod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode fmodValue(VM vm, double b);
+  mozart::UnstableNode fmodValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode pow(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode pow(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode powValue(VM vm, double b);
+  mozart::UnstableNode powValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode abs(VM vm);
+  mozart::UnstableNode abs(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode acos(VM vm);
+  mozart::UnstableNode acos(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode acosh(VM vm);
+  mozart::UnstableNode acosh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode asin(VM vm);
+  mozart::UnstableNode asin(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode asinh(VM vm);
+  mozart::UnstableNode asinh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode atan(VM vm);
+  mozart::UnstableNode atan(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode atanh(VM vm);
+  mozart::UnstableNode atanh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode atan2(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode atan2(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode atan2Value(VM vm, double b);
+  mozart::UnstableNode atan2Value(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode ceil(VM vm);
+  mozart::UnstableNode ceil(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode cos(VM vm);
+  mozart::UnstableNode cos(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode cosh(VM vm);
+  mozart::UnstableNode cosh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode exp(VM vm);
+  mozart::UnstableNode exp(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode floor(VM vm);
+  mozart::UnstableNode floor(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode log(VM vm);
+  mozart::UnstableNode log(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode round(VM vm);
+  mozart::UnstableNode round(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode sin(VM vm);
+  mozart::UnstableNode sin(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode sinh(VM vm);
+  mozart::UnstableNode sinh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode sqrt(VM vm);
+  mozart::UnstableNode sqrt(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode tan(VM vm);
+  mozart::UnstableNode tan(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode tanh(VM vm);
+  mozart::UnstableNode tanh(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Float-implem.hh b/vm/boostenv/main/cached/Float-implem.hh
index 80b8de832..70319222b 100644
--- a/vm/boostenv/main/cached/Float-implem.hh
+++ b/vm/boostenv/main/cached/Float-implem.hh
@@ -31,216 +31,216 @@ double  TypedRichNode<Float>::value() {
 }
 
 inline
-bool  TypedRichNode<Float>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Float>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Float>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Float>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<Float>::isNumber(VM vm) {
+bool  TypedRichNode<Float>::isNumber(mozart::VM vm) {
   return _self.access<Float>().isNumber(vm);
 }
 
 inline
-bool  TypedRichNode<Float>::isInt(VM vm) {
+bool  TypedRichNode<Float>::isInt(mozart::VM vm) {
   return _self.access<Float>().isInt(vm);
 }
 
 inline
-bool  TypedRichNode<Float>::isFloat(VM vm) {
+bool  TypedRichNode<Float>::isFloat(mozart::VM vm) {
   return _self.access<Float>().isFloat(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::opposite(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::opposite(mozart::VM vm) {
   return _self.access<Float>().opposite(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::add(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::add(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().add(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::add(VM vm, nativeint right) {
+mozart::UnstableNode  TypedRichNode<Float>::add(mozart::VM vm, mozart::nativeint right) {
   return _self.access<Float>().add(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::addValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::addValue(mozart::VM vm, double b) {
   return _self.access<Float>().addValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::subtract(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::subtract(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().subtract(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::subtractValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::subtractValue(mozart::VM vm, double b) {
   return _self.access<Float>().subtractValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::multiply(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::multiply(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().multiply(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::multiplyValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::multiplyValue(mozart::VM vm, double b) {
   return _self.access<Float>().multiplyValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::divide(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::divide(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().divide(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::divideValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::divideValue(mozart::VM vm, double b) {
   return _self.access<Float>().divideValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::fmod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::fmod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().fmod(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::fmodValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::fmodValue(mozart::VM vm, double b) {
   return _self.access<Float>().fmodValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::div(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::div(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().div(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::mod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::mod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().mod(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::pow(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::pow(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().pow(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::powValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::powValue(mozart::VM vm, double b) {
   return _self.access<Float>().powValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::abs(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::abs(mozart::VM vm) {
   return _self.access<Float>().abs(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::acos(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::acos(mozart::VM vm) {
   return _self.access<Float>().acos(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::acosh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::acosh(mozart::VM vm) {
   return _self.access<Float>().acosh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::asin(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::asin(mozart::VM vm) {
   return _self.access<Float>().asin(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::asinh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::asinh(mozart::VM vm) {
   return _self.access<Float>().asinh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atan(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::atan(mozart::VM vm) {
   return _self.access<Float>().atan(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atanh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::atanh(mozart::VM vm) {
   return _self.access<Float>().atanh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atan2(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::atan2(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().atan2(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atan2Value(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::atan2Value(mozart::VM vm, double b) {
   return _self.access<Float>().atan2Value(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::ceil(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::ceil(mozart::VM vm) {
   return _self.access<Float>().ceil(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::cos(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::cos(mozart::VM vm) {
   return _self.access<Float>().cos(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::cosh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::cosh(mozart::VM vm) {
   return _self.access<Float>().cosh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::exp(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::exp(mozart::VM vm) {
   return _self.access<Float>().exp(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::floor(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::floor(mozart::VM vm) {
   return _self.access<Float>().floor(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::log(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::log(mozart::VM vm) {
   return _self.access<Float>().log(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::round(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::round(mozart::VM vm) {
   return _self.access<Float>().round(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::sin(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::sin(mozart::VM vm) {
   return _self.access<Float>().sin(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::sinh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::sinh(mozart::VM vm) {
   return _self.access<Float>().sinh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::sqrt(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::sqrt(mozart::VM vm) {
   return _self.access<Float>().sqrt(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::tan(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::tan(mozart::VM vm) {
   return _self.access<Float>().tan(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::tanh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::tanh(mozart::VM vm) {
   return _self.access<Float>().tanh(vm);
 }
 
 inline
-void  TypedRichNode<Float>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Float>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Float>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/FloatLike-interf.hh b/vm/boostenv/main/cached/FloatLike-interf.hh
index 5ed019bcb..378ed579a 100644
--- a/vm/boostenv/main/cached/FloatLike-interf.hh
+++ b/vm/boostenv/main/cached/FloatLike-interf.hh
@@ -4,7 +4,7 @@ public:
   FloatLike(UnstableNode& self) : _self(self) {}
   FloatLike(StableNode& self) : _self(self) {}
 
-  class mozart::UnstableNode divide(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode divide(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().divide(vm, right);
     } else if (_self.isTransient()) {
@@ -12,7 +12,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::divide", "divide", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode pow(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode pow(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().pow(vm, right);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::pow", "pow", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode fmod(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode fmod(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().fmod(vm, right);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::fmod", "fmod", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode acos(VM vm) {
+  mozart::UnstableNode acos(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().acos(vm);
     } else if (_self.isTransient()) {
@@ -60,7 +60,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::acos", "acos", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -68,7 +68,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode acosh(VM vm) {
+  mozart::UnstableNode acosh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().acosh(vm);
     } else if (_self.isTransient()) {
@@ -76,7 +76,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::acosh", "acosh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -84,7 +84,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode asin(VM vm) {
+  mozart::UnstableNode asin(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().asin(vm);
     } else if (_self.isTransient()) {
@@ -92,7 +92,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::asin", "asin", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -100,7 +100,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode asinh(VM vm) {
+  mozart::UnstableNode asinh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().asinh(vm);
     } else if (_self.isTransient()) {
@@ -108,7 +108,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::asinh", "asinh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -116,7 +116,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode atan(VM vm) {
+  mozart::UnstableNode atan(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().atan(vm);
     } else if (_self.isTransient()) {
@@ -124,7 +124,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::atan", "atan", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -132,7 +132,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode atanh(VM vm) {
+  mozart::UnstableNode atanh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().atanh(vm);
     } else if (_self.isTransient()) {
@@ -140,7 +140,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::atanh", "atanh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -148,7 +148,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode atan2(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode atan2(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().atan2(vm, right);
     } else if (_self.isTransient()) {
@@ -156,7 +156,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::atan2", "atan2", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -164,7 +164,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode ceil(VM vm) {
+  mozart::UnstableNode ceil(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().ceil(vm);
     } else if (_self.isTransient()) {
@@ -172,7 +172,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::ceil", "ceil", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -180,7 +180,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode cos(VM vm) {
+  mozart::UnstableNode cos(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().cos(vm);
     } else if (_self.isTransient()) {
@@ -188,7 +188,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::cos", "cos", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -196,7 +196,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode cosh(VM vm) {
+  mozart::UnstableNode cosh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().cosh(vm);
     } else if (_self.isTransient()) {
@@ -204,7 +204,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::cosh", "cosh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -212,7 +212,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode exp(VM vm) {
+  mozart::UnstableNode exp(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().exp(vm);
     } else if (_self.isTransient()) {
@@ -220,7 +220,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::exp", "exp", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -228,7 +228,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode floor(VM vm) {
+  mozart::UnstableNode floor(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().floor(vm);
     } else if (_self.isTransient()) {
@@ -236,7 +236,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::floor", "floor", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -244,7 +244,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode log(VM vm) {
+  mozart::UnstableNode log(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().log(vm);
     } else if (_self.isTransient()) {
@@ -252,7 +252,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::log", "log", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -260,7 +260,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode round(VM vm) {
+  mozart::UnstableNode round(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().round(vm);
     } else if (_self.isTransient()) {
@@ -268,7 +268,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::round", "round", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -276,7 +276,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sin(VM vm) {
+  mozart::UnstableNode sin(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().sin(vm);
     } else if (_self.isTransient()) {
@@ -284,7 +284,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::sin", "sin", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -292,7 +292,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sinh(VM vm) {
+  mozart::UnstableNode sinh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().sinh(vm);
     } else if (_self.isTransient()) {
@@ -300,7 +300,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::sinh", "sinh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -308,7 +308,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sqrt(VM vm) {
+  mozart::UnstableNode sqrt(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().sqrt(vm);
     } else if (_self.isTransient()) {
@@ -316,7 +316,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::sqrt", "sqrt", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -324,7 +324,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode tan(VM vm) {
+  mozart::UnstableNode tan(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().tan(vm);
     } else if (_self.isTransient()) {
@@ -332,7 +332,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::tan", "tan", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -340,7 +340,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode tanh(VM vm) {
+  mozart::UnstableNode tanh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().tanh(vm);
     } else if (_self.isTransient()) {
@@ -348,7 +348,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::tanh", "tanh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/GRedToStable-implem-decl-after.hh b/vm/boostenv/main/cached/GRedToStable-implem-decl-after.hh
index 1e6f61480..d770190bd 100644
--- a/vm/boostenv/main/cached/GRedToStable-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/GRedToStable-implem-decl-after.hh
@@ -22,5 +22,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * dest();
+  mozart::StableNode * dest();
 };
diff --git a/vm/boostenv/main/cached/GRedToStable-implem-decl.hh b/vm/boostenv/main/cached/GRedToStable-implem-decl.hh
index daad688fd..8a239de87 100644
--- a/vm/boostenv/main/cached/GRedToStable-implem-decl.hh
+++ b/vm/boostenv/main/cached/GRedToStable-implem-decl.hh
@@ -3,5 +3,5 @@ class GRedToStable;
 template <>
 class Storage<GRedToStable> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/GRedToStable-implem.hh b/vm/boostenv/main/cached/GRedToStable-implem.hh
index 1f13544ad..8991ab6a7 100644
--- a/vm/boostenv/main/cached/GRedToStable-implem.hh
+++ b/vm/boostenv/main/cached/GRedToStable-implem.hh
@@ -1,5 +1,5 @@
 
 inline
-class mozart::StableNode *  TypedRichNode<GRedToStable>::dest() {
+mozart::StableNode *  TypedRichNode<GRedToStable>::dest() {
   return _self.access<GRedToStable>().dest();
 }
diff --git a/vm/boostenv/main/cached/GRedToUnstable-implem-decl-after.hh b/vm/boostenv/main/cached/GRedToUnstable-implem-decl-after.hh
index f3b6b92f0..12e0cfaec 100644
--- a/vm/boostenv/main/cached/GRedToUnstable-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/GRedToUnstable-implem-decl-after.hh
@@ -22,5 +22,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::UnstableNode * dest();
+  mozart::UnstableNode * dest();
 };
diff --git a/vm/boostenv/main/cached/GRedToUnstable-implem-decl.hh b/vm/boostenv/main/cached/GRedToUnstable-implem-decl.hh
index 853fbcf76..31dcdde51 100644
--- a/vm/boostenv/main/cached/GRedToUnstable-implem-decl.hh
+++ b/vm/boostenv/main/cached/GRedToUnstable-implem-decl.hh
@@ -3,5 +3,5 @@ class GRedToUnstable;
 template <>
 class Storage<GRedToUnstable> {
 public:
-  typedef class mozart::UnstableNode * Type;
+  typedef mozart::UnstableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/GRedToUnstable-implem.hh b/vm/boostenv/main/cached/GRedToUnstable-implem.hh
index 25623d55d..f2b8cb91a 100644
--- a/vm/boostenv/main/cached/GRedToUnstable-implem.hh
+++ b/vm/boostenv/main/cached/GRedToUnstable-implem.hh
@@ -1,5 +1,5 @@
 
 inline
-class mozart::UnstableNode *  TypedRichNode<GRedToUnstable>::dest() {
+mozart::UnstableNode *  TypedRichNode<GRedToUnstable>::dest() {
   return _self.access<GRedToUnstable>().dest();
 }
diff --git a/vm/boostenv/main/cached/GlobalName-implem-decl-after.hh b/vm/boostenv/main/cached/GlobalName-implem-decl-after.hh
index e1af26e47..2a40df500 100644
--- a/vm/boostenv/main/cached/GlobalName-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/GlobalName-implem-decl-after.hh
@@ -48,59 +48,59 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  const struct mozart::UUID & getUUID();
+  const mozart::UUID & getUUID();
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/GlobalName-implem.hh b/vm/boostenv/main/cached/GlobalName-implem.hh
index e4e1a44bc..88bd11044 100644
--- a/vm/boostenv/main/cached/GlobalName-implem.hh
+++ b/vm/boostenv/main/cached/GlobalName-implem.hh
@@ -44,96 +44,96 @@ int TypeInfoOf<GlobalName>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) c
 
 
 inline
-class mozart::Space *  TypedRichNode<GlobalName>::home() {
+mozart::Space *  TypedRichNode<GlobalName>::home() {
   return _self.access<GlobalName>().home();
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isLiteral(VM vm) {
+bool  TypedRichNode<GlobalName>::isLiteral(mozart::VM vm) {
   return _self.access<GlobalName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<GlobalName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<GlobalName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<GlobalName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<GlobalName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isRecord(VM vm) {
+bool  TypedRichNode<GlobalName>::isRecord(mozart::VM vm) {
   return _self.access<GlobalName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isTuple(VM vm) {
+bool  TypedRichNode<GlobalName>::isTuple(mozart::VM vm) {
   return _self.access<GlobalName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::label(mozart::VM vm) {
   return _self.access<GlobalName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<GlobalName>::width(VM vm) {
+size_t  TypedRichNode<GlobalName>::width(mozart::VM vm) {
   return _self.access<GlobalName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::arityList(mozart::VM vm) {
   return _self.access<GlobalName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::clone(mozart::VM vm) {
   return _self.access<GlobalName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::waitOr(mozart::VM vm) {
   return _self.access<GlobalName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<GlobalName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<GlobalName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<GlobalName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<GlobalName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<GlobalName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<GlobalName>().testLabel(_self, vm, label);
 }
 
 inline
-const struct mozart::UUID &  TypedRichNode<GlobalName>::getUUID() {
+const mozart::UUID &  TypedRichNode<GlobalName>::getUUID() {
   return _self.access<GlobalName>().getUUID();
 }
 
 inline
-int  TypedRichNode<GlobalName>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<GlobalName>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<GlobalName>().compareFeatures(vm, right);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isName(VM vm) {
+bool  TypedRichNode<GlobalName>::isName(mozart::VM vm) {
   return _self.access<GlobalName>().isName(vm);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<GlobalName>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<GlobalName>::globalize(mozart::VM vm) {
   return _self.access<GlobalName>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<GlobalName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<GlobalName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<GlobalName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Literal-interf.hh b/vm/boostenv/main/cached/Literal-interf.hh
index f0a885d9d..30f51823c 100644
--- a/vm/boostenv/main/cached/Literal-interf.hh
+++ b/vm/boostenv/main/cached/Literal-interf.hh
@@ -4,7 +4,7 @@ public:
   Literal(UnstableNode& self) : _self(self) {}
   Literal(StableNode& self) : _self(self) {}
 
-  bool isLiteral(VM vm) {
+  bool isLiteral(mozart::VM vm) {
     if (_self.is<Atom>()) {
       return _self.as<Atom>().isLiteral(vm);
     } else if (_self.is<OptName>()) {
diff --git a/vm/boostenv/main/cached/MergedSpace-implem-decl-after.hh b/vm/boostenv/main/cached/MergedSpace-implem-decl-after.hh
index 3bde0a933..557923f3a 100644
--- a/vm/boostenv/main/cached/MergedSpace-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/MergedSpace-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isSpace(VM vm);
+  bool isSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askSpace(VM vm);
+  mozart::UnstableNode askSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askVerboseSpace(VM vm);
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode mergeSpace(VM vm);
+  mozart::UnstableNode mergeSpace(mozart::VM vm);
 
   inline
-  void commitSpace(VM vm, class mozart::RichNode value);
+  void commitSpace(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode cloneSpace(VM vm);
+  mozart::UnstableNode cloneSpace(mozart::VM vm);
 
   inline
-  void killSpace(VM vm);
+  void killSpace(mozart::VM vm);
 };
diff --git a/vm/boostenv/main/cached/MergedSpace-implem-decl.hh b/vm/boostenv/main/cached/MergedSpace-implem-decl.hh
index aff5c8efb..03469ff4c 100644
--- a/vm/boostenv/main/cached/MergedSpace-implem-decl.hh
+++ b/vm/boostenv/main/cached/MergedSpace-implem-decl.hh
@@ -3,5 +3,5 @@ class MergedSpace;
 template <>
 class Storage<MergedSpace> {
 public:
-  typedef struct mozart::unit_t Type;
+  typedef mozart::unit_t Type;
 };
diff --git a/vm/boostenv/main/cached/MergedSpace-implem.hh b/vm/boostenv/main/cached/MergedSpace-implem.hh
index bb4e3744d..4ef9df96d 100644
--- a/vm/boostenv/main/cached/MergedSpace-implem.hh
+++ b/vm/boostenv/main/cached/MergedSpace-implem.hh
@@ -20,36 +20,36 @@ void TypeInfoOf<MergedSpace>::sClone(SC sc, RichNode from, UnstableNode& to) con
 }
 
 inline
-bool  TypedRichNode<MergedSpace>::isSpace(VM vm) {
+bool  TypedRichNode<MergedSpace>::isSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().isSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::askSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::askSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().askSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::askVerboseSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::askVerboseSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().askVerboseSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::mergeSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::mergeSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().mergeSpace(vm);
 }
 
 inline
-void  TypedRichNode<MergedSpace>::commitSpace(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<MergedSpace>::commitSpace(mozart::VM vm, mozart::RichNode value) {
   _self.access<MergedSpace>().commitSpace(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::cloneSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::cloneSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().cloneSpace(vm);
 }
 
 inline
-void  TypedRichNode<MergedSpace>::killSpace(VM vm) {
+void  TypedRichNode<MergedSpace>::killSpace(mozart::VM vm) {
   _self.access<MergedSpace>().killSpace(vm);
 }
diff --git a/vm/boostenv/main/cached/NameLike-interf.hh b/vm/boostenv/main/cached/NameLike-interf.hh
index e5c82d4e6..72b138925 100644
--- a/vm/boostenv/main/cached/NameLike-interf.hh
+++ b/vm/boostenv/main/cached/NameLike-interf.hh
@@ -4,7 +4,7 @@ public:
   NameLike(UnstableNode& self) : _self(self) {}
   NameLike(StableNode& self) : _self(self) {}
 
-  bool isName(VM vm) {
+  bool isName(mozart::VM vm) {
     if (_self.is<OptName>()) {
       return _self.as<OptName>().isName(vm);
     } else if (_self.is<GlobalName>()) {
diff --git a/vm/boostenv/main/cached/NamedName-implem-decl-after.hh b/vm/boostenv/main/cached/NamedName-implem-decl-after.hh
index bd92add5e..2c981f9a8 100644
--- a/vm/boostenv/main/cached/NamedName-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/NamedName-implem-decl-after.hh
@@ -51,65 +51,65 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  const struct mozart::UUID & getUUID();
+  const mozart::UUID & getUUID();
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/NamedName-implem.hh b/vm/boostenv/main/cached/NamedName-implem.hh
index 322a89afa..1fcc1a859 100644
--- a/vm/boostenv/main/cached/NamedName-implem.hh
+++ b/vm/boostenv/main/cached/NamedName-implem.hh
@@ -49,106 +49,106 @@ int TypeInfoOf<NamedName>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) co
 
 
 inline
-class mozart::Space *  TypedRichNode<NamedName>::home() {
+mozart::Space *  TypedRichNode<NamedName>::home() {
   return _self.access<NamedName>().home();
 }
 
 inline
-bool  TypedRichNode<NamedName>::isLiteral(VM vm) {
+bool  TypedRichNode<NamedName>::isLiteral(mozart::VM vm) {
   return _self.access<NamedName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<NamedName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<NamedName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<NamedName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<NamedName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<NamedName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<NamedName>::isRecord(VM vm) {
+bool  TypedRichNode<NamedName>::isRecord(mozart::VM vm) {
   return _self.access<NamedName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::isTuple(VM vm) {
+bool  TypedRichNode<NamedName>::isTuple(mozart::VM vm) {
   return _self.access<NamedName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::label(mozart::VM vm) {
   return _self.access<NamedName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<NamedName>::width(VM vm) {
+size_t  TypedRichNode<NamedName>::width(mozart::VM vm) {
   return _self.access<NamedName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::arityList(mozart::VM vm) {
   return _self.access<NamedName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::clone(mozart::VM vm) {
   return _self.access<NamedName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::waitOr(mozart::VM vm) {
   return _self.access<NamedName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<NamedName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<NamedName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<NamedName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<NamedName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<NamedName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<NamedName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<NamedName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<NamedName>().testLabel(_self, vm, label);
 }
 
 inline
-const struct mozart::UUID &  TypedRichNode<NamedName>::getUUID() {
+const mozart::UUID &  TypedRichNode<NamedName>::getUUID() {
   return _self.access<NamedName>().getUUID();
 }
 
 inline
-int  TypedRichNode<NamedName>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<NamedName>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<NamedName>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<NamedName>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<NamedName>::getPrintName(mozart::VM vm) {
   return _self.access<NamedName>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::isName(VM vm) {
+bool  TypedRichNode<NamedName>::isName(mozart::VM vm) {
   return _self.access<NamedName>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<NamedName>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<NamedName>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<NamedName>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<NamedName>::globalize(mozart::VM vm) {
   return _self.access<NamedName>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<NamedName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<NamedName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<NamedName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Numeric-interf.hh b/vm/boostenv/main/cached/Numeric-interf.hh
index bc54a5970..7ca56dc3a 100644
--- a/vm/boostenv/main/cached/Numeric-interf.hh
+++ b/vm/boostenv/main/cached/Numeric-interf.hh
@@ -4,7 +4,7 @@ public:
   Numeric(UnstableNode& self) : _self(self) {}
   Numeric(StableNode& self) : _self(self) {}
 
-  bool isNumber(VM vm) {
+  bool isNumber(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().isNumber(vm);
     } else if (_self.is<BigInt>()) {
@@ -24,7 +24,7 @@ public:
     }
   }
 
-  bool isInt(VM vm) {
+  bool isInt(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().isInt(vm);
     } else if (_self.is<BigInt>()) {
@@ -44,7 +44,7 @@ public:
     }
   }
 
-  bool isFloat(VM vm) {
+  bool isFloat(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().isFloat(vm);
     } else if (_self.is<BigInt>()) {
@@ -64,7 +64,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode opposite(VM vm) {
+  mozart::UnstableNode opposite(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().opposite(vm);
     } else if (_self.is<BigInt>()) {
@@ -76,7 +76,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::opposite", "opposite", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -84,7 +84,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().add(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -96,7 +96,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::add", "add", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -104,7 +104,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode add(VM vm, nativeint right) {
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().add(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -116,7 +116,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::add", "add", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -124,7 +124,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().subtract(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -136,7 +136,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::subtract", "subtract", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -144,7 +144,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().multiply(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -156,7 +156,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::multiply", "multiply", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -164,7 +164,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().div(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -176,7 +176,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::div", "div", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -184,7 +184,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().mod(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -196,7 +196,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::mod", "mod", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -204,7 +204,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode abs(VM vm) {
+  mozart::UnstableNode abs(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().abs(vm);
     } else if (_self.is<BigInt>()) {
@@ -216,7 +216,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::abs", "abs", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/Object-implem-decl-after.hh b/vm/boostenv/main/cached/Object-implem-decl-after.hh
index 7fa0a65e0..d21398dc1 100644
--- a/vm/boostenv/main/cached/Object-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Object-implem-decl-after.hh
@@ -45,59 +45,59 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::UnstableNode> getElementsArray();
+  StaticArray<mozart::UnstableNode> getElementsArray();
 
   inline
-  class mozart::UnstableNode& getElements(size_t i);
+  mozart::UnstableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getFeaturesRecord();
+  mozart::StableNode * getFeaturesRecord();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isChunk(VM vm);
+  bool isChunk(mozart::VM vm);
 
   inline
-  bool isObject(VM vm);
+  bool isObject(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode getClass(VM vm);
+  mozart::UnstableNode getClass(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode attrGet(VM vm, class mozart::RichNode attribute);
+  mozart::UnstableNode attrGet(mozart::VM vm, mozart::RichNode attribute);
 
   inline
-  void attrPut(VM vm, class mozart::RichNode attribute, class mozart::RichNode value);
+  void attrPut(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode attrExchange(VM vm, class mozart::RichNode attribute, class mozart::RichNode newValue);
+  mozart::UnstableNode attrExchange(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode newValue);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Object-implem-decl.hh b/vm/boostenv/main/cached/Object-implem-decl.hh
index fb6aa23b2..003b6dded 100644
--- a/vm/boostenv/main/cached/Object-implem-decl.hh
+++ b/vm/boostenv/main/cached/Object-implem-decl.hh
@@ -3,5 +3,5 @@ class Object;
 template <>
 class Storage<Object> {
 public:
-  typedef ImplWithArray<Object, class mozart::UnstableNode> Type;
+  typedef ImplWithArray<Object, mozart::UnstableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Object-implem.hh b/vm/boostenv/main/cached/Object-implem.hh
index 9ea9fd70a..b64af5029 100644
--- a/vm/boostenv/main/cached/Object-implem.hh
+++ b/vm/boostenv/main/cached/Object-implem.hh
@@ -37,16 +37,16 @@ size_t TypedRichNode<Object>::getArraySize() {
   return _self.access<Object>().getArraySize();
 }
 
-StaticArray<class mozart::UnstableNode> TypedRichNode<Object>::getElementsArray() {
+StaticArray<mozart::UnstableNode> TypedRichNode<Object>::getElementsArray() {
   return _self.access<Object>().getElementsArray();
 }
 
-class mozart::UnstableNode& TypedRichNode<Object>::getElements(size_t i) {
+mozart::UnstableNode& TypedRichNode<Object>::getElements(size_t i) {
   return _self.access<Object>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Object>::home() {
+mozart::Space *  TypedRichNode<Object>::home() {
   return _self.access<Object>().home();
 }
 
@@ -56,76 +56,76 @@ size_t  TypedRichNode<Object>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Object>::getFeaturesRecord() {
+mozart::StableNode *  TypedRichNode<Object>::getFeaturesRecord() {
   return _self.access<Object>().getFeaturesRecord();
 }
 
 inline
-bool  TypedRichNode<Object>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Object>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Object>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Object>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Object>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Object>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Object>::isChunk(VM vm) {
+bool  TypedRichNode<Object>::isChunk(mozart::VM vm) {
   return _self.access<Object>().isChunk(vm);
 }
 
 inline
-bool  TypedRichNode<Object>::isObject(VM vm) {
+bool  TypedRichNode<Object>::isObject(mozart::VM vm) {
   return _self.access<Object>().isObject(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Object>::getClass(VM vm) {
+mozart::UnstableNode  TypedRichNode<Object>::getClass(mozart::VM vm) {
   return _self.access<Object>().getClass(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Object>::attrGet(VM vm, class mozart::RichNode attribute) {
+mozart::UnstableNode  TypedRichNode<Object>::attrGet(mozart::VM vm, mozart::RichNode attribute) {
   return _self.access<Object>().attrGet(_self, vm, attribute);
 }
 
 inline
-void  TypedRichNode<Object>::attrPut(VM vm, class mozart::RichNode attribute, class mozart::RichNode value) {
+void  TypedRichNode<Object>::attrPut(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode value) {
   _self.access<Object>().attrPut(_self, vm, attribute, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Object>::attrExchange(VM vm, class mozart::RichNode attribute, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Object>::attrExchange(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode newValue) {
   return _self.access<Object>().attrExchange(_self, vm, attribute, newValue);
 }
 
 inline
-bool  TypedRichNode<Object>::isCallable(VM vm) {
+bool  TypedRichNode<Object>::isCallable(mozart::VM vm) {
   return _self.access<Object>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<Object>::isProcedure(VM vm) {
+bool  TypedRichNode<Object>::isProcedure(mozart::VM vm) {
   return _self.access<Object>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<Object>::procedureArity(VM vm) {
+size_t  TypedRichNode<Object>::procedureArity(mozart::VM vm) {
   return _self.access<Object>().procedureArity(_self, vm);
 }
 
 inline
-void  TypedRichNode<Object>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<Object>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<Object>().getCallInfo(_self, vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<Object>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<Object>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<Object>().getDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<Object>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Object>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Object>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ObjectLike-interf.hh b/vm/boostenv/main/cached/ObjectLike-interf.hh
index c51e26493..974a9ce94 100644
--- a/vm/boostenv/main/cached/ObjectLike-interf.hh
+++ b/vm/boostenv/main/cached/ObjectLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ObjectLike(UnstableNode& self) : _self(self) {}
   ObjectLike(StableNode& self) : _self(self) {}
 
-  bool isObject(VM vm) {
+  bool isObject(mozart::VM vm) {
     if (_self.is<Object>()) {
       return _self.as<Object>().isObject(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode getClass(VM vm) {
+  mozart::UnstableNode getClass(mozart::VM vm) {
     if (_self.is<Object>()) {
       return _self.as<Object>().getClass(vm);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ObjectLike::getClass", "getClass", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode attrGet(VM vm, class mozart::RichNode attribute) {
+  mozart::UnstableNode attrGet(mozart::VM vm, mozart::RichNode attribute) {
     if (_self.is<Object>()) {
       return _self.as<Object>().attrGet(vm, attribute);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ObjectLike::attrGet", "attrGet", attribute, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  void attrPut(VM vm, class mozart::RichNode attribute, class mozart::RichNode value) {
+  void attrPut(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode value) {
     if (_self.is<Object>()) {
       return _self.as<Object>().attrPut(vm, attribute, value);
     } else if (_self.isTransient()) {
@@ -67,7 +67,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode attrExchange(VM vm, class mozart::RichNode attribute, class mozart::RichNode newValue) {
+  mozart::UnstableNode attrExchange(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode newValue) {
     if (_self.is<Object>()) {
       return _self.as<Object>().attrExchange(vm, attribute, newValue);
     } else if (_self.isTransient()) {
@@ -75,7 +75,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ObjectLike::attrExchange", "attrExchange", attribute, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/OptName-implem-decl-after.hh b/vm/boostenv/main/cached/OptName-implem-decl-after.hh
index 8cf97a211..d569f3ebd 100644
--- a/vm/boostenv/main/cached/OptName-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/OptName-implem-decl-after.hh
@@ -45,56 +45,56 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void makeFeature(VM vm);
+  void makeFeature(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/OptName-implem-decl.hh b/vm/boostenv/main/cached/OptName-implem-decl.hh
index 0ed0d4ab0..2aad0d9f7 100644
--- a/vm/boostenv/main/cached/OptName-implem-decl.hh
+++ b/vm/boostenv/main/cached/OptName-implem-decl.hh
@@ -3,5 +3,5 @@ class OptName;
 template <>
 class Storage<OptName> {
 public:
-  typedef struct mozart::SpaceRef Type;
+  typedef mozart::SpaceRef Type;
 };
diff --git a/vm/boostenv/main/cached/OptName-implem.hh b/vm/boostenv/main/cached/OptName-implem.hh
index f13f5537c..09f2264ff 100644
--- a/vm/boostenv/main/cached/OptName-implem.hh
+++ b/vm/boostenv/main/cached/OptName-implem.hh
@@ -39,91 +39,91 @@ void TypeInfoOf<OptName>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<OptName>::home() {
+mozart::Space *  TypedRichNode<OptName>::home() {
   return _self.access<OptName>().home();
 }
 
 inline
-bool  TypedRichNode<OptName>::isLiteral(VM vm) {
+bool  TypedRichNode<OptName>::isLiteral(mozart::VM vm) {
   return _self.access<OptName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<OptName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<OptName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<OptName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<OptName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<OptName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<OptName>::isRecord(VM vm) {
+bool  TypedRichNode<OptName>::isRecord(mozart::VM vm) {
   return _self.access<OptName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::isTuple(VM vm) {
+bool  TypedRichNode<OptName>::isTuple(mozart::VM vm) {
   return _self.access<OptName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::label(mozart::VM vm) {
   return _self.access<OptName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<OptName>::width(VM vm) {
+size_t  TypedRichNode<OptName>::width(mozart::VM vm) {
   return _self.access<OptName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::arityList(mozart::VM vm) {
   return _self.access<OptName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::clone(mozart::VM vm) {
   return _self.access<OptName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::waitOr(mozart::VM vm) {
   return _self.access<OptName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<OptName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<OptName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<OptName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<OptName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<OptName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<OptName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<OptName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<OptName>().testLabel(_self, vm, label);
 }
 
 inline
-void  TypedRichNode<OptName>::makeFeature(VM vm) {
+void  TypedRichNode<OptName>::makeFeature(mozart::VM vm) {
   _self.access<OptName>().makeFeature(_self, vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::isName(VM vm) {
+bool  TypedRichNode<OptName>::isName(mozart::VM vm) {
   return _self.access<OptName>().isName(vm);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<OptName>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<OptName>::globalize(mozart::VM vm) {
   return _self.access<OptName>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<OptName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<OptName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<OptName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/OptVar-implem-decl-after.hh b/vm/boostenv/main/cached/OptVar-implem-decl-after.hh
index 008159bef..736bc8bdf 100644
--- a/vm/boostenv/main/cached/OptVar-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/OptVar-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::UnstableNode && src);
+  void bind(mozart::VM vm, mozart::UnstableNode && src);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/OptVar-implem-decl.hh b/vm/boostenv/main/cached/OptVar-implem-decl.hh
index 8c2b657fd..0317b422f 100644
--- a/vm/boostenv/main/cached/OptVar-implem-decl.hh
+++ b/vm/boostenv/main/cached/OptVar-implem-decl.hh
@@ -3,5 +3,5 @@ class OptVar;
 template <>
 class Storage<OptVar> {
 public:
-  typedef struct mozart::SpaceRef Type;
+  typedef mozart::SpaceRef Type;
 };
diff --git a/vm/boostenv/main/cached/OptVar-implem.hh b/vm/boostenv/main/cached/OptVar-implem.hh
index 50226a95e..263a43939 100644
--- a/vm/boostenv/main/cached/OptVar-implem.hh
+++ b/vm/boostenv/main/cached/OptVar-implem.hh
@@ -34,36 +34,36 @@ void TypeInfoOf<OptVar>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<OptVar>::home() {
+mozart::Space *  TypedRichNode<OptVar>::home() {
   return _self.access<OptVar>().home();
 }
 
 inline
-void  TypedRichNode<OptVar>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<OptVar>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<OptVar>().addToSuspendList(_self, vm, variable);
 }
 
 inline
-bool  TypedRichNode<OptVar>::isNeeded(VM vm) {
+bool  TypedRichNode<OptVar>::isNeeded(mozart::VM vm) {
   return _self.access<OptVar>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<OptVar>::markNeeded(VM vm) {
+void  TypedRichNode<OptVar>::markNeeded(mozart::VM vm) {
   _self.access<OptVar>().markNeeded(_self, vm);
 }
 
 inline
-void  TypedRichNode<OptVar>::bind(VM vm, class mozart::UnstableNode && src) {
+void  TypedRichNode<OptVar>::bind(mozart::VM vm, mozart::UnstableNode && src) {
   _self.access<OptVar>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<OptVar>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<OptVar>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<OptVar>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<OptVar>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<OptVar>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<OptVar>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/PatMatCapture-implem-decl-after.hh b/vm/boostenv/main/cached/PatMatCapture-implem-decl-after.hh
index 321e88774..79d0613ec 100644
--- a/vm/boostenv/main/cached/PatMatCapture-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/PatMatCapture-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<PatMatCapture>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("PatMatCapture", uuid(), (! ::mozart::MemWord::requiresExternalMemory<nativeint>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("PatMatCapture", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::nativeint>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<PatMatCapture>* const instance() {
     return &RawType<PatMatCapture>::rawType;
@@ -41,14 +41,14 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  nativeint index();
+  mozart::nativeint index();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/PatMatCapture-implem-decl.hh b/vm/boostenv/main/cached/PatMatCapture-implem-decl.hh
index f3090965b..6eae9b615 100644
--- a/vm/boostenv/main/cached/PatMatCapture-implem-decl.hh
+++ b/vm/boostenv/main/cached/PatMatCapture-implem-decl.hh
@@ -3,5 +3,5 @@ class PatMatCapture;
 template <>
 class Storage<PatMatCapture> {
 public:
-  typedef nativeint Type;
+  typedef mozart::nativeint Type;
 };
diff --git a/vm/boostenv/main/cached/PatMatCapture-implem.hh b/vm/boostenv/main/cached/PatMatCapture-implem.hh
index d42c86d86..a95caf2a6 100644
--- a/vm/boostenv/main/cached/PatMatCapture-implem.hh
+++ b/vm/boostenv/main/cached/PatMatCapture-implem.hh
@@ -31,21 +31,21 @@ void TypeInfoOf<PatMatCapture>::sClone(SC sc, RichNode from, UnstableNode& to) c
 }
 
 inline
-nativeint  TypedRichNode<PatMatCapture>::index() {
+mozart::nativeint  TypedRichNode<PatMatCapture>::index() {
   return _self.access<PatMatCapture>().index();
 }
 
 inline
-bool  TypedRichNode<PatMatCapture>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<PatMatCapture>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<PatMatCapture>().equals(vm, right);
 }
 
 inline
-void  TypedRichNode<PatMatCapture>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<PatMatCapture>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<PatMatCapture>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<PatMatCapture>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<PatMatCapture>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<PatMatCapture>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/PatMatConjunction-implem-decl-after.hh b/vm/boostenv/main/cached/PatMatConjunction-implem-decl-after.hh
index e89baac01..36b79ca31 100644
--- a/vm/boostenv/main/cached/PatMatConjunction-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/PatMatConjunction-implem-decl-after.hh
@@ -44,10 +44,10 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
@@ -56,14 +56,14 @@ public:
   size_t getCount();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/PatMatConjunction-implem-decl.hh b/vm/boostenv/main/cached/PatMatConjunction-implem-decl.hh
index 8fa48dec6..7b85b228f 100644
--- a/vm/boostenv/main/cached/PatMatConjunction-implem-decl.hh
+++ b/vm/boostenv/main/cached/PatMatConjunction-implem-decl.hh
@@ -3,5 +3,5 @@ class PatMatConjunction;
 template <>
 class Storage<PatMatConjunction> {
 public:
-  typedef ImplWithArray<PatMatConjunction, class mozart::StableNode> Type;
+  typedef ImplWithArray<PatMatConjunction, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/PatMatConjunction-implem.hh b/vm/boostenv/main/cached/PatMatConjunction-implem.hh
index 598418b75..74e009a67 100644
--- a/vm/boostenv/main/cached/PatMatConjunction-implem.hh
+++ b/vm/boostenv/main/cached/PatMatConjunction-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<PatMatConjunction>::getArraySize() {
   return _self.access<PatMatConjunction>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<PatMatConjunction>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<PatMatConjunction>::getElementsArray() {
   return _self.access<PatMatConjunction>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<PatMatConjunction>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<PatMatConjunction>::getElements(size_t i) {
   return _self.access<PatMatConjunction>().getElements(i);
 }
 
@@ -53,21 +53,21 @@ size_t  TypedRichNode<PatMatConjunction>::getCount() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<PatMatConjunction>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<PatMatConjunction>::getElement(size_t index) {
   return _self.access<PatMatConjunction>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<PatMatConjunction>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<PatMatConjunction>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<PatMatConjunction>().equals(vm, right, stack);
 }
 
 inline
-void  TypedRichNode<PatMatConjunction>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<PatMatConjunction>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<PatMatConjunction>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<PatMatConjunction>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<PatMatConjunction>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<PatMatConjunction>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl-after.hh b/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl-after.hh
index 5337cd28b..da7dfed9a 100644
--- a/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl-after.hh
@@ -44,23 +44,23 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  class mozart::StableNode * getArity();
+  mozart::StableNode * getArity();
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl.hh b/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl.hh
index c16fdab30..27af0c35f 100644
--- a/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl.hh
+++ b/vm/boostenv/main/cached/PatMatOpenRecord-implem-decl.hh
@@ -3,5 +3,5 @@ class PatMatOpenRecord;
 template <>
 class Storage<PatMatOpenRecord> {
 public:
-  typedef ImplWithArray<PatMatOpenRecord, class mozart::StableNode> Type;
+  typedef ImplWithArray<PatMatOpenRecord, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/PatMatOpenRecord-implem.hh b/vm/boostenv/main/cached/PatMatOpenRecord-implem.hh
index cd155e426..835b802f8 100644
--- a/vm/boostenv/main/cached/PatMatOpenRecord-implem.hh
+++ b/vm/boostenv/main/cached/PatMatOpenRecord-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<PatMatOpenRecord>::getArraySize() {
   return _self.access<PatMatOpenRecord>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<PatMatOpenRecord>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<PatMatOpenRecord>::getElementsArray() {
   return _self.access<PatMatOpenRecord>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<PatMatOpenRecord>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<PatMatOpenRecord>::getElements(size_t i) {
   return _self.access<PatMatOpenRecord>().getElements(i);
 }
 
@@ -48,21 +48,21 @@ size_t  TypedRichNode<PatMatOpenRecord>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getElement(size_t index) {
   return _self.access<PatMatOpenRecord>().getElement(index);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getArity() {
+mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getArity() {
   return _self.access<PatMatOpenRecord>().getArity();
 }
 
 inline
-void  TypedRichNode<PatMatOpenRecord>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<PatMatOpenRecord>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<PatMatOpenRecord>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<PatMatOpenRecord>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<PatMatOpenRecord>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<PatMatOpenRecord>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/Port-implem-decl-after.hh b/vm/boostenv/main/cached/Port-implem-decl-after.hh
index d277a737f..3fe77f3ae 100644
--- a/vm/boostenv/main/cached/Port-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Port-implem-decl-after.hh
@@ -42,17 +42,17 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isPort(VM vm);
+  bool isPort(mozart::VM vm);
 
   inline
-  void send(VM vm, class mozart::RichNode value);
+  void send(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode sendReceive(VM vm, class mozart::RichNode value);
+  mozart::UnstableNode sendReceive(mozart::VM vm, mozart::RichNode value);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Port-implem.hh b/vm/boostenv/main/cached/Port-implem.hh
index 66fededf2..2822dd614 100644
--- a/vm/boostenv/main/cached/Port-implem.hh
+++ b/vm/boostenv/main/cached/Port-implem.hh
@@ -34,26 +34,26 @@ void TypeInfoOf<Port>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<Port>::home() {
+mozart::Space *  TypedRichNode<Port>::home() {
   return _self.access<Port>().home();
 }
 
 inline
-bool  TypedRichNode<Port>::isPort(VM vm) {
+bool  TypedRichNode<Port>::isPort(mozart::VM vm) {
   return _self.access<Port>().isPort(vm);
 }
 
 inline
-void  TypedRichNode<Port>::send(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<Port>::send(mozart::VM vm, mozart::RichNode value) {
   _self.access<Port>().send(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Port>::sendReceive(VM vm, class mozart::RichNode value) {
+mozart::UnstableNode  TypedRichNode<Port>::sendReceive(mozart::VM vm, mozart::RichNode value) {
   return _self.access<Port>().sendReceive(vm, value);
 }
 
 inline
-void  TypedRichNode<Port>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Port>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Port>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/PortLike-interf.hh b/vm/boostenv/main/cached/PortLike-interf.hh
index b001e3d26..bc8313344 100644
--- a/vm/boostenv/main/cached/PortLike-interf.hh
+++ b/vm/boostenv/main/cached/PortLike-interf.hh
@@ -4,7 +4,7 @@ public:
   PortLike(UnstableNode& self) : _self(self) {}
   PortLike(StableNode& self) : _self(self) {}
 
-  bool isPort(VM vm) {
+  bool isPort(mozart::VM vm) {
     if (_self.is<Port>()) {
       return _self.as<Port>().isPort(vm);
     } else if (_self.is<VMPort>()) {
@@ -22,7 +22,7 @@ public:
     }
   }
 
-  void send(VM vm, class mozart::RichNode value) {
+  void send(mozart::VM vm, mozart::RichNode value) {
     if (_self.is<Port>()) {
       return _self.as<Port>().send(vm, value);
     } else if (_self.is<VMPort>()) {
@@ -39,7 +39,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sendReceive(VM vm, class mozart::RichNode value) {
+  mozart::UnstableNode sendReceive(mozart::VM vm, mozart::RichNode value) {
     if (_self.is<Port>()) {
       return _self.as<Port>().sendReceive(vm, value);
     } else if (_self.is<VMPort>()) {
@@ -49,7 +49,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::PortLike::sendReceive", "sendReceive", value, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/boostenv/main/cached/PotentialFeature-interf.hh b/vm/boostenv/main/cached/PotentialFeature-interf.hh
index 206771623..3d8bf1f64 100644
--- a/vm/boostenv/main/cached/PotentialFeature-interf.hh
+++ b/vm/boostenv/main/cached/PotentialFeature-interf.hh
@@ -4,7 +4,7 @@ public:
   PotentialFeature(UnstableNode& self) : _self(self) {}
   PotentialFeature(StableNode& self) : _self(self) {}
 
-  void makeFeature(VM vm) {
+  void makeFeature(mozart::VM vm) {
     if (_self.is<OptName>()) {
       return _self.as<OptName>().makeFeature(vm);
     } else if (_self.isTransient()) {
diff --git a/vm/boostenv/main/cached/ReadOnly-implem-decl-after.hh b/vm/boostenv/main/cached/ReadOnly-implem-decl-after.hh
index 8f23c5529..a4af6999f 100644
--- a/vm/boostenv/main/cached/ReadOnly-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReadOnly-implem-decl-after.hh
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 
   inline
-  void wakeUp(VM vm);
+  void wakeUp(mozart::VM vm);
 
   inline
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space);
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space);
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/ReadOnly-implem-decl.hh b/vm/boostenv/main/cached/ReadOnly-implem-decl.hh
index b654dcbb4..33d9f29de 100644
--- a/vm/boostenv/main/cached/ReadOnly-implem-decl.hh
+++ b/vm/boostenv/main/cached/ReadOnly-implem-decl.hh
@@ -3,5 +3,5 @@ class ReadOnly;
 template <>
 class Storage<ReadOnly> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/ReadOnly-implem.hh b/vm/boostenv/main/cached/ReadOnly-implem.hh
index ab24fdc54..ea2bd3858 100644
--- a/vm/boostenv/main/cached/ReadOnly-implem.hh
+++ b/vm/boostenv/main/cached/ReadOnly-implem.hh
@@ -12,9 +12,7 @@ void TypeInfoOf<ReadOnly>::gCollect(GC gc, RichNode from, StableNode& to) const
 
 void TypeInfoOf<ReadOnly>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<ReadOnly>(gc->vm, gc, from.access<ReadOnly>());
+  to.make<ReadOnly>(gc->vm, gc, from.access<ReadOnly>());
 }
 
 void TypeInfoOf<ReadOnly>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -28,41 +26,41 @@ void TypeInfoOf<ReadOnly>::sClone(SC sc, RichNode from, UnstableNode& to) const
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<ReadOnly>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<ReadOnly>::getUnderlying() {
   return _self.access<ReadOnly>().getUnderlying();
 }
 
 inline
-void  TypedRichNode<ReadOnly>::wakeUp(VM vm) {
+void  TypedRichNode<ReadOnly>::wakeUp(mozart::VM vm) {
   _self.access<ReadOnly>().wakeUp(_self, vm);
 }
 
 inline
-bool  TypedRichNode<ReadOnly>::shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+bool  TypedRichNode<ReadOnly>::shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
   return _self.access<ReadOnly>().shouldWakeUpUnderSpace(vm, space);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<ReadOnly>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<ReadOnly>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<ReadOnly>::isNeeded(VM vm) {
+bool  TypedRichNode<ReadOnly>::isNeeded(mozart::VM vm) {
   return _self.access<ReadOnly>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::markNeeded(VM vm) {
+void  TypedRichNode<ReadOnly>::markNeeded(mozart::VM vm) {
   _self.access<ReadOnly>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReadOnly>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReadOnly>().bind(vm, src);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReadOnly>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReadOnly>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ReadOnlyVariable-implem-decl-after.hh b/vm/boostenv/main/cached/ReadOnlyVariable-implem-decl-after.hh
index 3dba028a5..4d228f087 100644
--- a/vm/boostenv/main/cached/ReadOnlyVariable-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReadOnlyVariable-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void bindReadOnly(VM vm, class mozart::RichNode src);
+  void bindReadOnly(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/ReadOnlyVariable-implem.hh b/vm/boostenv/main/cached/ReadOnlyVariable-implem.hh
index 72f5c8661..26d5f8243 100644
--- a/vm/boostenv/main/cached/ReadOnlyVariable-implem.hh
+++ b/vm/boostenv/main/cached/ReadOnlyVariable-implem.hh
@@ -26,36 +26,36 @@ void TypeInfoOf<ReadOnlyVariable>::sClone(SC sc, RichNode from, UnstableNode& to
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReadOnlyVariable>::home() {
+mozart::Space *  TypedRichNode<ReadOnlyVariable>::home() {
   return _self.access<ReadOnlyVariable>().home();
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<ReadOnlyVariable>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<ReadOnlyVariable>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<ReadOnlyVariable>::isNeeded(VM vm) {
+bool  TypedRichNode<ReadOnlyVariable>::isNeeded(mozart::VM vm) {
   return _self.access<ReadOnlyVariable>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::markNeeded(VM vm) {
+void  TypedRichNode<ReadOnlyVariable>::markNeeded(mozart::VM vm) {
   _self.access<ReadOnlyVariable>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReadOnlyVariable>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReadOnlyVariable>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::bindReadOnly(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReadOnlyVariable>::bindReadOnly(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReadOnlyVariable>().bindReadOnly(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReadOnlyVariable>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReadOnlyVariable>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Record-implem-decl-after.hh b/vm/boostenv/main/cached/Record-implem-decl-after.hh
index ed2dcb8d3..01cf0a381 100644
--- a/vm/boostenv/main/cached/Record-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Record-implem-decl-after.hh
@@ -48,10 +48,10 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
@@ -60,53 +60,53 @@ public:
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  class mozart::StableNode * getArity();
+  mozart::StableNode * getArity();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/Record-implem-decl.hh b/vm/boostenv/main/cached/Record-implem-decl.hh
index 65117e3ae..2718b2de7 100644
--- a/vm/boostenv/main/cached/Record-implem-decl.hh
+++ b/vm/boostenv/main/cached/Record-implem-decl.hh
@@ -3,5 +3,5 @@ class Record;
 template <>
 class Storage<Record> {
 public:
-  typedef ImplWithArray<Record, class mozart::StableNode> Type;
+  typedef ImplWithArray<Record, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Record-implem.hh b/vm/boostenv/main/cached/Record-implem.hh
index 0c9ea6f2c..3b7085b1c 100644
--- a/vm/boostenv/main/cached/Record-implem.hh
+++ b/vm/boostenv/main/cached/Record-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Record>::getArraySize() {
   return _self.access<Record>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Record>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Record>::getElementsArray() {
   return _self.access<Record>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Record>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Record>::getElements(size_t i) {
   return _self.access<Record>().getElements(i);
 }
 
@@ -53,86 +53,86 @@ size_t  TypedRichNode<Record>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Record>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Record>::getElement(size_t index) {
   return _self.access<Record>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Record>::isRecord(VM vm) {
+bool  TypedRichNode<Record>::isRecord(mozart::VM vm) {
   return _self.access<Record>().isRecord(vm);
 }
 
 inline
-size_t  TypedRichNode<Record>::width(VM vm) {
+size_t  TypedRichNode<Record>::width(mozart::VM vm) {
   return _self.access<Record>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::arityList(mozart::VM vm) {
   return _self.access<Record>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::waitOr(mozart::VM vm) {
   return _self.access<Record>().waitOr(vm);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Record>::getArity() {
+mozart::StableNode *  TypedRichNode<Record>::getArity() {
   return _self.access<Record>().getArity();
 }
 
 inline
-bool  TypedRichNode<Record>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Record>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Record>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Record>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Record>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Record>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Record>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Record>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Record>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Record>::isTuple(VM vm) {
+bool  TypedRichNode<Record>::isTuple(mozart::VM vm) {
   return _self.access<Record>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::label(mozart::VM vm) {
   return _self.access<Record>().label(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::clone(mozart::VM vm) {
   return _self.access<Record>().clone(vm);
 }
 
 inline
-bool  TypedRichNode<Record>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Record>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Record>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Record>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Record>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Record>().testTuple(vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Record>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Record>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Record>().testLabel(vm, label);
 }
 
 inline
-void  TypedRichNode<Record>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Record>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Record>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Record>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Record>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/RecordLike-interf.hh b/vm/boostenv/main/cached/RecordLike-interf.hh
index 68d4313a9..7ea645c25 100644
--- a/vm/boostenv/main/cached/RecordLike-interf.hh
+++ b/vm/boostenv/main/cached/RecordLike-interf.hh
@@ -4,7 +4,7 @@ public:
   RecordLike(UnstableNode& self) : _self(self) {}
   RecordLike(StableNode& self) : _self(self) {}
 
-  bool isRecord(VM vm) {
+  bool isRecord(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().isRecord(vm);
     } else if (_self.is<Record>()) {
@@ -29,7 +29,7 @@ public:
     }
   }
 
-  bool isTuple(VM vm) {
+  bool isTuple(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().isTuple(vm);
     } else if (_self.is<Record>()) {
@@ -54,7 +54,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode label(VM vm) {
+  mozart::UnstableNode label(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().label(vm);
     } else if (_self.is<Record>()) {
@@ -79,7 +79,7 @@ public:
     }
   }
 
-  size_t width(VM vm) {
+  size_t width(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().width(vm);
     } else if (_self.is<Record>()) {
@@ -104,7 +104,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arityList(VM vm) {
+  mozart::UnstableNode arityList(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().arityList(vm);
     } else if (_self.is<Record>()) {
@@ -129,7 +129,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode clone(VM vm) {
+  mozart::UnstableNode clone(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().clone(vm);
     } else if (_self.is<Record>()) {
@@ -154,7 +154,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode waitOr(VM vm) {
+  mozart::UnstableNode waitOr(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().waitOr(vm);
     } else if (_self.is<Record>()) {
@@ -179,7 +179,7 @@ public:
     }
   }
 
-  bool testRecord(VM vm, class mozart::RichNode arity) {
+  bool testRecord(mozart::VM vm, mozart::RichNode arity) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().testRecord(vm, arity);
     } else if (_self.is<Record>()) {
@@ -204,7 +204,7 @@ public:
     }
   }
 
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width) {
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().testTuple(vm, label, width);
     } else if (_self.is<Record>()) {
@@ -229,7 +229,7 @@ public:
     }
   }
 
-  bool testLabel(VM vm, class mozart::RichNode label) {
+  bool testLabel(mozart::VM vm, mozart::RichNode label) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().testLabel(vm, label);
     } else if (_self.is<Record>()) {
diff --git a/vm/boostenv/main/cached/Reference-implem-decl-after.hh b/vm/boostenv/main/cached/Reference-implem-decl-after.hh
index 4afce2e5f..f0d962547 100644
--- a/vm/boostenv/main/cached/Reference-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Reference-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<Reference>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("Reference", uuid(), (! ::mozart::MemWord::requiresExternalMemory<class mozart::StableNode *>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("Reference", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::StableNode *>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<Reference>* const instance() {
     return &RawType<Reference>::rawType;
@@ -34,5 +34,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * dest();
+  mozart::StableNode * dest();
 };
diff --git a/vm/boostenv/main/cached/Reference-implem-decl.hh b/vm/boostenv/main/cached/Reference-implem-decl.hh
index 65450d9e6..88e3946b5 100644
--- a/vm/boostenv/main/cached/Reference-implem-decl.hh
+++ b/vm/boostenv/main/cached/Reference-implem-decl.hh
@@ -3,5 +3,5 @@ class Reference;
 template <>
 class Storage<Reference> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/Reference-implem.hh b/vm/boostenv/main/cached/Reference-implem.hh
index aee78981d..c75725374 100644
--- a/vm/boostenv/main/cached/Reference-implem.hh
+++ b/vm/boostenv/main/cached/Reference-implem.hh
@@ -6,9 +6,7 @@ void TypeInfoOf<Reference>::gCollect(GC gc, RichNode from, StableNode& to) const
 
 void TypeInfoOf<Reference>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<Reference>(gc->vm, gc, from.access<Reference>());
+  to.make<Reference>(gc->vm, gc, from.access<Reference>());
 }
 
 void TypeInfoOf<Reference>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -18,12 +16,10 @@ void TypeInfoOf<Reference>::sClone(SC sc, RichNode from, StableNode& to) const {
 
 void TypeInfoOf<Reference>::sClone(SC sc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (sc->vm) StableNode;
-to.make<Reference>(sc->vm, stable);
-stable->make<Reference>(sc->vm, sc, from.access<Reference>());
+  to.make<Reference>(sc->vm, sc, from.access<Reference>());
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Reference>::dest() {
+mozart::StableNode *  TypedRichNode<Reference>::dest() {
   return _self.access<Reference>().dest();
 }
diff --git a/vm/boostenv/main/cached/ReflectiveEntity-implem-decl-after.hh b/vm/boostenv/main/cached/ReflectiveEntity-implem-decl-after.hh
index 6277b9d03..716cf6862 100644
--- a/vm/boostenv/main/cached/ReflectiveEntity-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReflectiveEntity-implem-decl-after.hh
@@ -43,8 +43,8 @@ public:
 
   template <typename Label, typename ... Args> 
   inline
-  bool reflectiveCall(VM vm, const char * identity, Label && label, Args &&... args);
+  bool reflectiveCall(mozart::VM vm, const char * identity, Label && label, Args &&... args);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/ReflectiveEntity-implem.hh b/vm/boostenv/main/cached/ReflectiveEntity-implem.hh
index a83b2dc04..4ea812666 100644
--- a/vm/boostenv/main/cached/ReflectiveEntity-implem.hh
+++ b/vm/boostenv/main/cached/ReflectiveEntity-implem.hh
@@ -27,11 +27,11 @@ void TypeInfoOf<ReflectiveEntity>::sClone(SC sc, RichNode from, UnstableNode& to
 
 template <typename Label, typename ... Args> 
 inline
-bool  TypedRichNode<ReflectiveEntity>::reflectiveCall(VM vm, const char * identity, Label && label, Args &&... args) {
+bool  TypedRichNode<ReflectiveEntity>::reflectiveCall(mozart::VM vm, const char * identity, Label && label, Args &&... args) {
   return _self.access<ReflectiveEntity>().reflectiveCall<Label, Args... >(vm, identity, std::forward<Label>(label), std::forward<Args>(args)...);
 }
 
 inline
-void  TypedRichNode<ReflectiveEntity>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReflectiveEntity>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReflectiveEntity>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ReflectiveVariable-implem-decl-after.hh b/vm/boostenv/main/cached/ReflectiveVariable-implem-decl-after.hh
index 5ba3a8d10..aa3eae9ff 100644
--- a/vm/boostenv/main/cached/ReflectiveVariable-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReflectiveVariable-implem-decl-after.hh
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void reflectiveBind(VM vm, class mozart::RichNode src);
+  void reflectiveBind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void bindReadOnly(VM vm, class mozart::RichNode src);
+  void bindReadOnly(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/ReflectiveVariable-implem.hh b/vm/boostenv/main/cached/ReflectiveVariable-implem.hh
index 1a71b7671..69f7ab847 100644
--- a/vm/boostenv/main/cached/ReflectiveVariable-implem.hh
+++ b/vm/boostenv/main/cached/ReflectiveVariable-implem.hh
@@ -26,41 +26,41 @@ void TypeInfoOf<ReflectiveVariable>::sClone(SC sc, RichNode from, UnstableNode&
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReflectiveVariable>::home() {
+mozart::Space *  TypedRichNode<ReflectiveVariable>::home() {
   return _self.access<ReflectiveVariable>().home();
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<ReflectiveVariable>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<ReflectiveVariable>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<ReflectiveVariable>::isNeeded(VM vm) {
+bool  TypedRichNode<ReflectiveVariable>::isNeeded(mozart::VM vm) {
   return _self.access<ReflectiveVariable>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::markNeeded(VM vm) {
+void  TypedRichNode<ReflectiveVariable>::markNeeded(mozart::VM vm) {
   _self.access<ReflectiveVariable>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReflectiveVariable>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReflectiveVariable>().bind(vm, src);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::reflectiveBind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReflectiveVariable>::reflectiveBind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReflectiveVariable>().reflectiveBind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::bindReadOnly(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReflectiveVariable>::bindReadOnly(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReflectiveVariable>().bindReadOnly(vm, src);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReflectiveVariable>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReflectiveVariable>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ReifiedGNode-implem-decl-after.hh b/vm/boostenv/main/cached/ReifiedGNode-implem-decl-after.hh
index 49e77794e..890d91154 100644
--- a/vm/boostenv/main/cached/ReifiedGNode-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReifiedGNode-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<ReifiedGNode>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("ReifiedGNode", uuid(), (! ::mozart::MemWord::requiresExternalMemory<class mozart::GlobalNode *>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("ReifiedGNode", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::GlobalNode *>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<ReifiedGNode>* const instance() {
     return &RawType<ReifiedGNode>::rawType;
@@ -38,8 +38,8 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::GlobalNode * value();
+  mozart::GlobalNode * value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 };
diff --git a/vm/boostenv/main/cached/ReifiedGNode-implem-decl.hh b/vm/boostenv/main/cached/ReifiedGNode-implem-decl.hh
index 249d3d035..09de5a7dd 100644
--- a/vm/boostenv/main/cached/ReifiedGNode-implem-decl.hh
+++ b/vm/boostenv/main/cached/ReifiedGNode-implem-decl.hh
@@ -3,5 +3,5 @@ class ReifiedGNode;
 template <>
 class Storage<ReifiedGNode> {
 public:
-  typedef class mozart::GlobalNode * Type;
+  typedef mozart::GlobalNode * Type;
 };
diff --git a/vm/boostenv/main/cached/ReifiedGNode-implem.hh b/vm/boostenv/main/cached/ReifiedGNode-implem.hh
index 66a7fe63c..65f19bc24 100644
--- a/vm/boostenv/main/cached/ReifiedGNode-implem.hh
+++ b/vm/boostenv/main/cached/ReifiedGNode-implem.hh
@@ -20,11 +20,11 @@ void TypeInfoOf<ReifiedGNode>::sClone(SC sc, RichNode from, UnstableNode& to) co
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<ReifiedGNode>::value() {
+mozart::GlobalNode *  TypedRichNode<ReifiedGNode>::value() {
   return _self.access<ReifiedGNode>().value();
 }
 
 inline
-bool  TypedRichNode<ReifiedGNode>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<ReifiedGNode>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ReifiedGNode>().equals(vm, right);
 }
diff --git a/vm/boostenv/main/cached/ReifiedSpace-implem-decl-after.hh b/vm/boostenv/main/cached/ReifiedSpace-implem-decl-after.hh
index abac9cdd4..98791fd58 100644
--- a/vm/boostenv/main/cached/ReifiedSpace-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReifiedSpace-implem-decl-after.hh
@@ -38,29 +38,29 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  class mozart::Space * getSpace();
+  mozart::Space * getSpace();
 
   inline
-  bool isSpace(VM vm);
+  bool isSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askSpace(VM vm);
+  mozart::UnstableNode askSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askVerboseSpace(VM vm);
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode mergeSpace(VM vm);
+  mozart::UnstableNode mergeSpace(mozart::VM vm);
 
   inline
-  void commitSpace(VM vm, class mozart::RichNode value);
+  void commitSpace(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode cloneSpace(VM vm);
+  mozart::UnstableNode cloneSpace(mozart::VM vm);
 
   inline
-  void killSpace(VM vm);
+  void killSpace(mozart::VM vm);
 };
diff --git a/vm/boostenv/main/cached/ReifiedSpace-implem-decl.hh b/vm/boostenv/main/cached/ReifiedSpace-implem-decl.hh
index d53a51ab9..2752ce98d 100644
--- a/vm/boostenv/main/cached/ReifiedSpace-implem-decl.hh
+++ b/vm/boostenv/main/cached/ReifiedSpace-implem-decl.hh
@@ -3,5 +3,5 @@ class ReifiedSpace;
 template <>
 class Storage<ReifiedSpace> {
 public:
-  typedef struct mozart::SpaceRef Type;
+  typedef mozart::SpaceRef Type;
 };
diff --git a/vm/boostenv/main/cached/ReifiedSpace-implem.hh b/vm/boostenv/main/cached/ReifiedSpace-implem.hh
index 52bf14d5c..51b0ba870 100644
--- a/vm/boostenv/main/cached/ReifiedSpace-implem.hh
+++ b/vm/boostenv/main/cached/ReifiedSpace-implem.hh
@@ -28,46 +28,46 @@ void TypeInfoOf<ReifiedSpace>::sClone(SC sc, RichNode from, UnstableNode& to) co
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReifiedSpace>::home() {
+mozart::Space *  TypedRichNode<ReifiedSpace>::home() {
   return _self.access<ReifiedSpace>().home();
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReifiedSpace>::getSpace() {
+mozart::Space *  TypedRichNode<ReifiedSpace>::getSpace() {
   return _self.access<ReifiedSpace>().getSpace();
 }
 
 inline
-bool  TypedRichNode<ReifiedSpace>::isSpace(VM vm) {
+bool  TypedRichNode<ReifiedSpace>::isSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().isSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().askSpace(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askVerboseSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askVerboseSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().askVerboseSpace(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::mergeSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::mergeSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().mergeSpace(_self, vm);
 }
 
 inline
-void  TypedRichNode<ReifiedSpace>::commitSpace(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<ReifiedSpace>::commitSpace(mozart::VM vm, mozart::RichNode value) {
   _self.access<ReifiedSpace>().commitSpace(_self, vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::cloneSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::cloneSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().cloneSpace(_self, vm);
 }
 
 inline
-void  TypedRichNode<ReifiedSpace>::killSpace(VM vm) {
+void  TypedRichNode<ReifiedSpace>::killSpace(mozart::VM vm) {
   _self.access<ReifiedSpace>().killSpace(_self, vm);
 }
diff --git a/vm/boostenv/main/cached/ReifiedThread-implem-decl-after.hh b/vm/boostenv/main/cached/ReifiedThread-implem-decl-after.hh
index e82bec556..8d3bf88b0 100644
--- a/vm/boostenv/main/cached/ReifiedThread-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/ReifiedThread-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<ReifiedThread>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("ReifiedThread", uuid(), (! ::mozart::MemWord::requiresExternalMemory<class mozart::Runnable *>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("ReifiedThread", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::Runnable *>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<ReifiedThread>* const instance() {
     return &RawType<ReifiedThread>::rawType;
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::Runnable * value();
+  mozart::Runnable * value();
 
   inline
-  void wakeUp(VM vm);
+  void wakeUp(mozart::VM vm);
 
   inline
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space);
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space);
 
   inline
-  bool isThread(VM vm);
+  bool isThread(mozart::VM vm);
 
   inline
-  enum mozart::ThreadPriority getThreadPriority(VM vm);
+  mozart::ThreadPriority getThreadPriority(mozart::VM vm);
 
   inline
-  void setThreadPriority(VM vm, enum mozart::ThreadPriority priority);
+  void setThreadPriority(mozart::VM vm, mozart::ThreadPriority priority);
 
   inline
-  void injectException(VM vm, class mozart::RichNode exception);
+  void injectException(mozart::VM vm, mozart::RichNode exception);
 };
diff --git a/vm/boostenv/main/cached/ReifiedThread-implem-decl.hh b/vm/boostenv/main/cached/ReifiedThread-implem-decl.hh
index a49eaa931..5c7e4c039 100644
--- a/vm/boostenv/main/cached/ReifiedThread-implem-decl.hh
+++ b/vm/boostenv/main/cached/ReifiedThread-implem-decl.hh
@@ -3,5 +3,5 @@ class ReifiedThread;
 template <>
 class Storage<ReifiedThread> {
 public:
-  typedef class mozart::Runnable * Type;
+  typedef mozart::Runnable * Type;
 };
diff --git a/vm/boostenv/main/cached/ReifiedThread-implem.hh b/vm/boostenv/main/cached/ReifiedThread-implem.hh
index 6f212a4c5..64324d3c4 100644
--- a/vm/boostenv/main/cached/ReifiedThread-implem.hh
+++ b/vm/boostenv/main/cached/ReifiedThread-implem.hh
@@ -6,9 +6,7 @@ void TypeInfoOf<ReifiedThread>::gCollect(GC gc, RichNode from, StableNode& to) c
 
 void TypeInfoOf<ReifiedThread>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<ReifiedThread>(gc->vm, gc, from.access<ReifiedThread>());
+  to.make<ReifiedThread>(gc->vm, gc, from.access<ReifiedThread>());
 }
 
 void TypeInfoOf<ReifiedThread>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -18,47 +16,45 @@ void TypeInfoOf<ReifiedThread>::sClone(SC sc, RichNode from, StableNode& to) con
 
 void TypeInfoOf<ReifiedThread>::sClone(SC sc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (sc->vm) StableNode;
-to.make<Reference>(sc->vm, stable);
-stable->make<ReifiedThread>(sc->vm, sc, from.access<ReifiedThread>());
+  to.make<ReifiedThread>(sc->vm, sc, from.access<ReifiedThread>());
 }
 
 inline
-bool  TypedRichNode<ReifiedThread>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<ReifiedThread>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ReifiedThread>().equals(vm, right);
 }
 
 inline
-class mozart::Runnable *  TypedRichNode<ReifiedThread>::value() {
+mozart::Runnable *  TypedRichNode<ReifiedThread>::value() {
   return _self.access<ReifiedThread>().value();
 }
 
 inline
-void  TypedRichNode<ReifiedThread>::wakeUp(VM vm) {
+void  TypedRichNode<ReifiedThread>::wakeUp(mozart::VM vm) {
   _self.access<ReifiedThread>().wakeUp(vm);
 }
 
 inline
-bool  TypedRichNode<ReifiedThread>::shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+bool  TypedRichNode<ReifiedThread>::shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
   return _self.access<ReifiedThread>().shouldWakeUpUnderSpace(vm, space);
 }
 
 inline
-bool  TypedRichNode<ReifiedThread>::isThread(VM vm) {
+bool  TypedRichNode<ReifiedThread>::isThread(mozart::VM vm) {
   return _self.access<ReifiedThread>().isThread(vm);
 }
 
 inline
-enum mozart::ThreadPriority  TypedRichNode<ReifiedThread>::getThreadPriority(VM vm) {
+mozart::ThreadPriority  TypedRichNode<ReifiedThread>::getThreadPriority(mozart::VM vm) {
   return _self.access<ReifiedThread>().getThreadPriority(vm);
 }
 
 inline
-void  TypedRichNode<ReifiedThread>::setThreadPriority(VM vm, enum mozart::ThreadPriority priority) {
+void  TypedRichNode<ReifiedThread>::setThreadPriority(mozart::VM vm, mozart::ThreadPriority priority) {
   _self.access<ReifiedThread>().setThreadPriority(vm, priority);
 }
 
 inline
-void  TypedRichNode<ReifiedThread>::injectException(VM vm, class mozart::RichNode exception) {
+void  TypedRichNode<ReifiedThread>::injectException(mozart::VM vm, mozart::RichNode exception) {
   _self.access<ReifiedThread>().injectException(vm, exception);
 }
diff --git a/vm/boostenv/main/cached/Serialized-implem-decl-after.hh b/vm/boostenv/main/cached/Serialized-implem-decl-after.hh
index 909beb2f5..4f1de9da3 100644
--- a/vm/boostenv/main/cached/Serialized-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Serialized-implem-decl-after.hh
@@ -34,5 +34,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  nativeint n();
+  mozart::nativeint n();
 };
diff --git a/vm/boostenv/main/cached/Serialized-implem-decl.hh b/vm/boostenv/main/cached/Serialized-implem-decl.hh
index b01cd62af..e612e11a4 100644
--- a/vm/boostenv/main/cached/Serialized-implem-decl.hh
+++ b/vm/boostenv/main/cached/Serialized-implem-decl.hh
@@ -3,5 +3,5 @@ class Serialized;
 template <>
 class Storage<Serialized> {
 public:
-  typedef nativeint Type;
+  typedef mozart::nativeint Type;
 };
diff --git a/vm/boostenv/main/cached/Serialized-implem.hh b/vm/boostenv/main/cached/Serialized-implem.hh
index 385e3a028..ad9c33d67 100644
--- a/vm/boostenv/main/cached/Serialized-implem.hh
+++ b/vm/boostenv/main/cached/Serialized-implem.hh
@@ -20,6 +20,6 @@ void TypeInfoOf<Serialized>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-nativeint  TypedRichNode<Serialized>::n() {
+mozart::nativeint  TypedRichNode<Serialized>::n() {
   return _self.access<Serialized>().n();
 }
diff --git a/vm/boostenv/main/cached/Serializer-implem-decl-after.hh b/vm/boostenv/main/cached/Serializer-implem-decl-after.hh
index 2d5402cbf..86ee36f77 100644
--- a/vm/boostenv/main/cached/Serializer-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Serializer-implem-decl-after.hh
@@ -38,5 +38,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::UnstableNode doSerialize(VM vm, class mozart::RichNode todo);
+  mozart::UnstableNode doSerialize(mozart::VM vm, mozart::RichNode todo);
 };
diff --git a/vm/boostenv/main/cached/Serializer-implem.hh b/vm/boostenv/main/cached/Serializer-implem.hh
index 55ea9b576..64f989168 100644
--- a/vm/boostenv/main/cached/Serializer-implem.hh
+++ b/vm/boostenv/main/cached/Serializer-implem.hh
@@ -20,6 +20,6 @@ void TypeInfoOf<Serializer>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Serializer>::doSerialize(VM vm, class mozart::RichNode todo) {
+mozart::UnstableNode  TypedRichNode<Serializer>::doSerialize(mozart::VM vm, mozart::RichNode todo) {
   return _self.access<Serializer>().doSerialize(vm, todo);
 }
diff --git a/vm/boostenv/main/cached/SmallInt-implem-decl-after.hh b/vm/boostenv/main/cached/SmallInt-implem-decl-after.hh
index 3d7ea39fa..b9578e1c0 100644
--- a/vm/boostenv/main/cached/SmallInt-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/SmallInt-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<SmallInt>: public TypeInfo {
     return SmallInt::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("SmallInt", uuid(), (! ::mozart::MemWord::requiresExternalMemory<nativeint>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("SmallInt", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::nativeint>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<SmallInt>* const instance() {
     return &RawType<SmallInt>::rawType;
@@ -45,62 +45,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  nativeint value();
+  mozart::nativeint value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isNumber(VM vm);
+  bool isNumber(mozart::VM vm);
 
   inline
-  bool isInt(VM vm);
+  bool isInt(mozart::VM vm);
 
   inline
-  bool isFloat(VM vm);
+  bool isFloat(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode opposite(VM vm);
+  mozart::UnstableNode opposite(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode add(VM vm, nativeint b);
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode subtractValue(VM vm, nativeint b);
+  mozart::UnstableNode subtractValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode multiplyValue(VM vm, nativeint b);
+  mozart::UnstableNode multiplyValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode divValue(VM vm, nativeint b);
+  mozart::UnstableNode divValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode modValue(VM vm, nativeint b);
+  mozart::UnstableNode modValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode abs(VM vm);
+  mozart::UnstableNode abs(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/SmallInt-implem-decl.hh b/vm/boostenv/main/cached/SmallInt-implem-decl.hh
index a73d2a540..16a780841 100644
--- a/vm/boostenv/main/cached/SmallInt-implem-decl.hh
+++ b/vm/boostenv/main/cached/SmallInt-implem-decl.hh
@@ -3,5 +3,5 @@ class SmallInt;
 template <>
 class Storage<SmallInt> {
 public:
-  typedef nativeint Type;
+  typedef mozart::nativeint Type;
 };
diff --git a/vm/boostenv/main/cached/SmallInt-implem.hh b/vm/boostenv/main/cached/SmallInt-implem.hh
index 65ee35ae6..a9ddd44e2 100644
--- a/vm/boostenv/main/cached/SmallInt-implem.hh
+++ b/vm/boostenv/main/cached/SmallInt-implem.hh
@@ -31,101 +31,101 @@ int TypeInfoOf<SmallInt>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) con
 
 
 inline
-nativeint  TypedRichNode<SmallInt>::value() {
+mozart::nativeint  TypedRichNode<SmallInt>::value() {
   return _self.access<SmallInt>().value();
 }
 
 inline
-bool  TypedRichNode<SmallInt>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<SmallInt>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<SmallInt>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<SmallInt>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().compareFeatures(vm, right);
 }
 
 inline
-int  TypedRichNode<SmallInt>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<SmallInt>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().compare(_self, vm, right);
 }
 
 inline
-bool  TypedRichNode<SmallInt>::isNumber(VM vm) {
+bool  TypedRichNode<SmallInt>::isNumber(mozart::VM vm) {
   return _self.access<SmallInt>().isNumber(vm);
 }
 
 inline
-bool  TypedRichNode<SmallInt>::isInt(VM vm) {
+bool  TypedRichNode<SmallInt>::isInt(mozart::VM vm) {
   return _self.access<SmallInt>().isInt(vm);
 }
 
 inline
-bool  TypedRichNode<SmallInt>::isFloat(VM vm) {
+bool  TypedRichNode<SmallInt>::isFloat(mozart::VM vm) {
   return _self.access<SmallInt>().isFloat(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::opposite(VM vm) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::opposite(mozart::VM vm) {
   return _self.access<SmallInt>().opposite(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::add(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::add(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().add(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::add(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::add(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().add(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::subtract(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::subtract(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().subtract(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::subtractValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::subtractValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().subtractValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::multiply(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::multiply(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().multiply(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::multiplyValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::multiplyValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().multiplyValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::div(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::div(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().div(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::divValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::divValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().divValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::mod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::mod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().mod(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::modValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::modValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().modValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::abs(VM vm) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::abs(mozart::VM vm) {
   return _self.access<SmallInt>().abs(vm);
 }
 
 inline
-void  TypedRichNode<SmallInt>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<SmallInt>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<SmallInt>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/SpaceLike-interf.hh b/vm/boostenv/main/cached/SpaceLike-interf.hh
index 14f801083..97cd93d84 100644
--- a/vm/boostenv/main/cached/SpaceLike-interf.hh
+++ b/vm/boostenv/main/cached/SpaceLike-interf.hh
@@ -4,7 +4,7 @@ public:
   SpaceLike(UnstableNode& self) : _self(self) {}
   SpaceLike(StableNode& self) : _self(self) {}
 
-  bool isSpace(VM vm) {
+  bool isSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().isSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -19,7 +19,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode askSpace(VM vm) {
+  mozart::UnstableNode askSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().askSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -34,7 +34,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode askVerboseSpace(VM vm) {
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().askVerboseSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -49,7 +49,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode mergeSpace(VM vm) {
+  mozart::UnstableNode mergeSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().mergeSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -64,7 +64,7 @@ public:
     }
   }
 
-  void commitSpace(VM vm, class mozart::RichNode value) {
+  void commitSpace(mozart::VM vm, mozart::RichNode value) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().commitSpace(vm, value);
     } else if (_self.is<FailedSpace>()) {
@@ -79,7 +79,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode cloneSpace(VM vm) {
+  mozart::UnstableNode cloneSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().cloneSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -94,7 +94,7 @@ public:
     }
   }
 
-  void killSpace(VM vm) {
+  void killSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().killSpace(vm);
     } else if (_self.is<FailedSpace>()) {
diff --git a/vm/boostenv/main/cached/String-implem-decl-after.hh b/vm/boostenv/main/cached/String-implem-decl-after.hh
index c9cb672ff..0fd0eb4ca 100644
--- a/vm/boostenv/main/cached/String-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/String-implem-decl-after.hh
@@ -45,47 +45,47 @@ public:
   const LString<char> & value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isString(VM vm);
+  bool isString(mozart::VM vm);
 
   inline
-  bool isByteString(VM vm);
+  bool isByteString(mozart::VM vm);
 
   inline
-  LString<char> * stringGet(VM vm);
+  LString<char> * stringGet(mozart::VM vm);
 
   inline
-  LString<unsigned char> * byteStringGet(VM vm);
+  LString<unsigned char> * byteStringGet(mozart::VM vm);
 
   inline
-  nativeint stringCharAt(VM vm, class mozart::RichNode offset);
+  mozart::nativeint stringCharAt(mozart::VM vm, mozart::RichNode offset);
 
   inline
-  class mozart::UnstableNode stringAppend(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode stringAppend(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to);
+  mozart::UnstableNode stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to);
 
   inline
-  void stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end);
+  void stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end);
 
   inline
-  bool stringHasPrefix(VM vm, class mozart::RichNode prefix);
+  bool stringHasPrefix(mozart::VM vm, mozart::RichNode prefix);
 
   inline
-  bool stringHasSuffix(VM vm, class mozart::RichNode suffix);
+  bool stringHasSuffix(mozart::VM vm, mozart::RichNode suffix);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/String-implem.hh b/vm/boostenv/main/cached/String-implem.hh
index e73601cee..501e2a712 100644
--- a/vm/boostenv/main/cached/String-implem.hh
+++ b/vm/boostenv/main/cached/String-implem.hh
@@ -31,76 +31,76 @@ const LString<char> &  TypedRichNode<String>::value() {
 }
 
 inline
-bool  TypedRichNode<String>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<String>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<String>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<String>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<String>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<String>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<String>::isString(VM vm) {
+bool  TypedRichNode<String>::isString(mozart::VM vm) {
   return _self.access<String>().isString(vm);
 }
 
 inline
-bool  TypedRichNode<String>::isByteString(VM vm) {
+bool  TypedRichNode<String>::isByteString(mozart::VM vm) {
   return _self.access<String>().isByteString(vm);
 }
 
 inline
-LString<char> *  TypedRichNode<String>::stringGet(VM vm) {
+LString<char> *  TypedRichNode<String>::stringGet(mozart::VM vm) {
   return _self.access<String>().stringGet(vm);
 }
 
 inline
-LString<unsigned char> *  TypedRichNode<String>::byteStringGet(VM vm) {
+LString<unsigned char> *  TypedRichNode<String>::byteStringGet(mozart::VM vm) {
   return _self.access<String>().byteStringGet(_self, vm);
 }
 
 inline
-nativeint  TypedRichNode<String>::stringCharAt(VM vm, class mozart::RichNode offset) {
+mozart::nativeint  TypedRichNode<String>::stringCharAt(mozart::VM vm, mozart::RichNode offset) {
   return _self.access<String>().stringCharAt(_self, vm, offset);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<String>::stringAppend(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<String>::stringAppend(mozart::VM vm, mozart::RichNode right) {
   return _self.access<String>().stringAppend(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<String>::stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to) {
+mozart::UnstableNode  TypedRichNode<String>::stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to) {
   return _self.access<String>().stringSlice(_self, vm, from, to);
 }
 
 inline
-void  TypedRichNode<String>::stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end) {
+void  TypedRichNode<String>::stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end) {
   _self.access<String>().stringSearch(_self, vm, from, needle, begin, end);
 }
 
 inline
-bool  TypedRichNode<String>::stringHasPrefix(VM vm, class mozart::RichNode prefix) {
+bool  TypedRichNode<String>::stringHasPrefix(mozart::VM vm, mozart::RichNode prefix) {
   return _self.access<String>().stringHasPrefix(vm, prefix);
 }
 
 inline
-bool  TypedRichNode<String>::stringHasSuffix(VM vm, class mozart::RichNode suffix) {
+bool  TypedRichNode<String>::stringHasSuffix(mozart::VM vm, mozart::RichNode suffix) {
   return _self.access<String>().stringHasSuffix(vm, suffix);
 }
 
 inline
-bool  TypedRichNode<String>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<String>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<String>().lookupFeature(_self, vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<String>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<String>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<String>().lookupFeature(_self, vm, feature, value);
 }
 
 inline
-void  TypedRichNode<String>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<String>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<String>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/StringLike-interf.hh b/vm/boostenv/main/cached/StringLike-interf.hh
index 3223fd985..51c0b5970 100644
--- a/vm/boostenv/main/cached/StringLike-interf.hh
+++ b/vm/boostenv/main/cached/StringLike-interf.hh
@@ -4,7 +4,7 @@ public:
   StringLike(UnstableNode& self) : _self(self) {}
   StringLike(StableNode& self) : _self(self) {}
 
-  bool isString(VM vm) {
+  bool isString(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().isString(vm);
     } else if (_self.is<ByteString>()) {
@@ -17,7 +17,7 @@ public:
     }
   }
 
-  bool isByteString(VM vm) {
+  bool isByteString(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().isByteString(vm);
     } else if (_self.is<ByteString>()) {
@@ -30,7 +30,7 @@ public:
     }
   }
 
-  LString<char> * stringGet(VM vm) {
+  LString<char> * stringGet(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().stringGet(vm);
     } else if (_self.is<ByteString>()) {
@@ -43,7 +43,7 @@ public:
     }
   }
 
-  LString<unsigned char> * byteStringGet(VM vm) {
+  LString<unsigned char> * byteStringGet(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().byteStringGet(vm);
     } else if (_self.is<ByteString>()) {
@@ -56,7 +56,7 @@ public:
     }
   }
 
-  nativeint stringCharAt(VM vm, class mozart::RichNode offset) {
+  mozart::nativeint stringCharAt(mozart::VM vm, mozart::RichNode offset) {
     if (_self.is<String>()) {
       return _self.as<String>().stringCharAt(vm, offset);
     } else if (_self.is<ByteString>()) {
@@ -69,7 +69,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode stringAppend(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode stringAppend(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<String>()) {
       return _self.as<String>().stringAppend(vm, right);
     } else if (_self.is<ByteString>()) {
@@ -82,7 +82,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to) {
+  mozart::UnstableNode stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to) {
     if (_self.is<String>()) {
       return _self.as<String>().stringSlice(vm, from, to);
     } else if (_self.is<ByteString>()) {
@@ -95,7 +95,7 @@ public:
     }
   }
 
-  void stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end) {
+  void stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end) {
     if (_self.is<String>()) {
       return _self.as<String>().stringSearch(vm, from, needle, begin, end);
     } else if (_self.is<ByteString>()) {
@@ -108,7 +108,7 @@ public:
     }
   }
 
-  bool stringHasPrefix(VM vm, class mozart::RichNode prefix) {
+  bool stringHasPrefix(mozart::VM vm, mozart::RichNode prefix) {
     if (_self.is<String>()) {
       return _self.as<String>().stringHasPrefix(vm, prefix);
     } else if (_self.is<ByteString>()) {
@@ -121,7 +121,7 @@ public:
     }
   }
 
-  bool stringHasSuffix(VM vm, class mozart::RichNode suffix) {
+  bool stringHasSuffix(mozart::VM vm, mozart::RichNode suffix) {
     if (_self.is<String>()) {
       return _self.as<String>().stringHasSuffix(vm, suffix);
     } else if (_self.is<ByteString>()) {
diff --git a/vm/boostenv/main/cached/StructuralEquatable-interf.hh b/vm/boostenv/main/cached/StructuralEquatable-interf.hh
index ec5ea82dc..c4ecb1b0e 100644
--- a/vm/boostenv/main/cached/StructuralEquatable-interf.hh
+++ b/vm/boostenv/main/cached/StructuralEquatable-interf.hh
@@ -4,7 +4,7 @@ public:
   StructuralEquatable(UnstableNode& self) : _self(self) {}
   StructuralEquatable(StableNode& self) : _self(self) {}
 
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().equals(vm, right, stack);
     } else if (_self.is<Cons>()) {
diff --git a/vm/boostenv/main/cached/ThreadLike-interf.hh b/vm/boostenv/main/cached/ThreadLike-interf.hh
index bbe1036e2..83fb2e935 100644
--- a/vm/boostenv/main/cached/ThreadLike-interf.hh
+++ b/vm/boostenv/main/cached/ThreadLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ThreadLike(UnstableNode& self) : _self(self) {}
   ThreadLike(StableNode& self) : _self(self) {}
 
-  bool isThread(VM vm) {
+  bool isThread(mozart::VM vm) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().isThread(vm);
     } else if (_self.isTransient()) {
@@ -15,7 +15,7 @@ public:
     }
   }
 
-  enum mozart::ThreadPriority getThreadPriority(VM vm) {
+  mozart::ThreadPriority getThreadPriority(mozart::VM vm) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().getThreadPriority(vm);
     } else if (_self.isTransient()) {
@@ -26,7 +26,7 @@ public:
     }
   }
 
-  void setThreadPriority(VM vm, enum mozart::ThreadPriority priority) {
+  void setThreadPriority(mozart::VM vm, mozart::ThreadPriority priority) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().setThreadPriority(vm, priority);
     } else if (_self.isTransient()) {
@@ -37,7 +37,7 @@ public:
     }
   }
 
-  void injectException(VM vm, class mozart::RichNode exception) {
+  void injectException(mozart::VM vm, mozart::RichNode exception) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().injectException(vm, exception);
     } else if (_self.isTransient()) {
diff --git a/vm/boostenv/main/cached/Tuple-implem-decl-after.hh b/vm/boostenv/main/cached/Tuple-implem-decl-after.hh
index 4ff3160a9..d20b5583e 100644
--- a/vm/boostenv/main/cached/Tuple-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Tuple-implem-decl-after.hh
@@ -48,10 +48,10 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
@@ -60,56 +60,56 @@ public:
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  class mozart::StableNode * getLabel();
+  mozart::StableNode * getLabel();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  bool hasSharpRepr(VM vm, int depth);
+  bool hasSharpRepr(mozart::VM vm, int depth);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/Tuple-implem-decl.hh b/vm/boostenv/main/cached/Tuple-implem-decl.hh
index c6dcd35da..c345361b0 100644
--- a/vm/boostenv/main/cached/Tuple-implem-decl.hh
+++ b/vm/boostenv/main/cached/Tuple-implem-decl.hh
@@ -3,5 +3,5 @@ class Tuple;
 template <>
 class Storage<Tuple> {
 public:
-  typedef ImplWithArray<Tuple, class mozart::StableNode> Type;
+  typedef ImplWithArray<Tuple, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Tuple-implem.hh b/vm/boostenv/main/cached/Tuple-implem.hh
index 0275bdd26..10130d89d 100644
--- a/vm/boostenv/main/cached/Tuple-implem.hh
+++ b/vm/boostenv/main/cached/Tuple-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Tuple>::getArraySize() {
   return _self.access<Tuple>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Tuple>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Tuple>::getElementsArray() {
   return _self.access<Tuple>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Tuple>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Tuple>::getElements(size_t i) {
   return _self.access<Tuple>().getElements(i);
 }
 
@@ -53,91 +53,91 @@ size_t  TypedRichNode<Tuple>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Tuple>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Tuple>::getElement(size_t index) {
   return _self.access<Tuple>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Tuple>::isRecord(VM vm) {
+bool  TypedRichNode<Tuple>::isRecord(mozart::VM vm) {
   return _self.access<Tuple>().isRecord(vm);
 }
 
 inline
-size_t  TypedRichNode<Tuple>::width(VM vm) {
+size_t  TypedRichNode<Tuple>::width(mozart::VM vm) {
   return _self.access<Tuple>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::arityList(mozart::VM vm) {
   return _self.access<Tuple>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::waitOr(mozart::VM vm) {
   return _self.access<Tuple>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Tuple>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Tuple>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Tuple>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Tuple>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Tuple>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Tuple>().lookupFeature(vm, feature, value);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Tuple>::getLabel() {
+mozart::StableNode *  TypedRichNode<Tuple>::getLabel() {
   return _self.access<Tuple>().getLabel();
 }
 
 inline
-bool  TypedRichNode<Tuple>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Tuple>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Tuple>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Tuple>::isTuple(VM vm) {
+bool  TypedRichNode<Tuple>::isTuple(mozart::VM vm) {
   return _self.access<Tuple>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::label(mozart::VM vm) {
   return _self.access<Tuple>().label(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::clone(mozart::VM vm) {
   return _self.access<Tuple>().clone(vm);
 }
 
 inline
-bool  TypedRichNode<Tuple>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Tuple>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Tuple>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Tuple>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Tuple>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Tuple>().testTuple(vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Tuple>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Tuple>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Tuple>().testLabel(vm, label);
 }
 
 inline
-void  TypedRichNode<Tuple>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Tuple>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Tuple>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-bool  TypedRichNode<Tuple>::hasSharpRepr(VM vm, int depth) {
+bool  TypedRichNode<Tuple>::hasSharpRepr(mozart::VM vm, int depth) {
   return _self.access<Tuple>().hasSharpRepr(vm, depth);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Tuple>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Tuple>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/UniqueName-implem-decl-after.hh b/vm/boostenv/main/cached/UniqueName-implem-decl-after.hh
index f16194068..ca8a8de12 100644
--- a/vm/boostenv/main/cached/UniqueName-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/UniqueName-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<UniqueName>: public TypeInfo {
     return UniqueName::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("UniqueName", uuid(), (! ::mozart::MemWord::requiresExternalMemory<unique_name_t>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("UniqueName", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::unique_name_t>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<UniqueName>* const instance() {
     return &RawType<UniqueName>::rawType;
@@ -48,62 +48,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  unique_name_t value();
+  mozart::unique_name_t value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/UniqueName-implem-decl.hh b/vm/boostenv/main/cached/UniqueName-implem-decl.hh
index b45187bb8..1b6dd0925 100644
--- a/vm/boostenv/main/cached/UniqueName-implem-decl.hh
+++ b/vm/boostenv/main/cached/UniqueName-implem-decl.hh
@@ -3,5 +3,5 @@ class UniqueName;
 template <>
 class Storage<UniqueName> {
 public:
-  typedef unique_name_t Type;
+  typedef mozart::unique_name_t Type;
 };
diff --git a/vm/boostenv/main/cached/UniqueName-implem.hh b/vm/boostenv/main/cached/UniqueName-implem.hh
index 18419f399..be5f6cbb5 100644
--- a/vm/boostenv/main/cached/UniqueName-implem.hh
+++ b/vm/boostenv/main/cached/UniqueName-implem.hh
@@ -36,101 +36,101 @@ int TypeInfoOf<UniqueName>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) c
 
 
 inline
-bool  TypedRichNode<UniqueName>::isLiteral(VM vm) {
+bool  TypedRichNode<UniqueName>::isLiteral(mozart::VM vm) {
   return _self.access<UniqueName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<UniqueName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<UniqueName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<UniqueName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<UniqueName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::isRecord(VM vm) {
+bool  TypedRichNode<UniqueName>::isRecord(mozart::VM vm) {
   return _self.access<UniqueName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::isTuple(VM vm) {
+bool  TypedRichNode<UniqueName>::isTuple(mozart::VM vm) {
   return _self.access<UniqueName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::label(mozart::VM vm) {
   return _self.access<UniqueName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<UniqueName>::width(VM vm) {
+size_t  TypedRichNode<UniqueName>::width(mozart::VM vm) {
   return _self.access<UniqueName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::arityList(mozart::VM vm) {
   return _self.access<UniqueName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::clone(mozart::VM vm) {
   return _self.access<UniqueName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::waitOr(mozart::VM vm) {
   return _self.access<UniqueName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<UniqueName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<UniqueName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<UniqueName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<UniqueName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<UniqueName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<UniqueName>().testLabel(_self, vm, label);
 }
 
 inline
-unique_name_t  TypedRichNode<UniqueName>::value() {
+mozart::unique_name_t  TypedRichNode<UniqueName>::value() {
   return _self.access<UniqueName>().value();
 }
 
 inline
-bool  TypedRichNode<UniqueName>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<UniqueName>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<UniqueName>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<UniqueName>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<UniqueName>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<UniqueName>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<UniqueName>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<UniqueName>::getPrintName(mozart::VM vm) {
   return _self.access<UniqueName>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::isName(VM vm) {
+bool  TypedRichNode<UniqueName>::isName(mozart::VM vm) {
   return _self.access<UniqueName>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<UniqueName>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<UniqueName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<UniqueName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<UniqueName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Unit-implem-decl-after.hh b/vm/boostenv/main/cached/Unit-implem-decl-after.hh
index d61f8fa7d..b37298aff 100644
--- a/vm/boostenv/main/cached/Unit-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Unit-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<Unit>: public TypeInfo {
     return Unit::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("Unit", uuid(), (! ::mozart::MemWord::requiresExternalMemory<struct mozart::unit_t>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("Unit", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::unit_t>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<Unit>* const instance() {
     return &RawType<Unit>::rawType;
@@ -48,59 +48,59 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Unit-implem-decl.hh b/vm/boostenv/main/cached/Unit-implem-decl.hh
index 27a79a997..103226762 100644
--- a/vm/boostenv/main/cached/Unit-implem-decl.hh
+++ b/vm/boostenv/main/cached/Unit-implem-decl.hh
@@ -3,5 +3,5 @@ class Unit;
 template <>
 class Storage<Unit> {
 public:
-  typedef struct mozart::unit_t Type;
+  typedef mozart::unit_t Type;
 };
diff --git a/vm/boostenv/main/cached/Unit-implem.hh b/vm/boostenv/main/cached/Unit-implem.hh
index a7fcaf0a3..74d03b44b 100644
--- a/vm/boostenv/main/cached/Unit-implem.hh
+++ b/vm/boostenv/main/cached/Unit-implem.hh
@@ -36,96 +36,96 @@ int TypeInfoOf<Unit>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) const {
 
 
 inline
-bool  TypedRichNode<Unit>::isLiteral(VM vm) {
+bool  TypedRichNode<Unit>::isLiteral(mozart::VM vm) {
   return _self.access<Unit>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Unit>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Unit>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Unit>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Unit>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Unit>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Unit>::isRecord(VM vm) {
+bool  TypedRichNode<Unit>::isRecord(mozart::VM vm) {
   return _self.access<Unit>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::isTuple(VM vm) {
+bool  TypedRichNode<Unit>::isTuple(mozart::VM vm) {
   return _self.access<Unit>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::label(mozart::VM vm) {
   return _self.access<Unit>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<Unit>::width(VM vm) {
+size_t  TypedRichNode<Unit>::width(mozart::VM vm) {
   return _self.access<Unit>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::arityList(mozart::VM vm) {
   return _self.access<Unit>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::clone(mozart::VM vm) {
   return _self.access<Unit>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::waitOr(mozart::VM vm) {
   return _self.access<Unit>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Unit>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Unit>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Unit>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Unit>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Unit>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Unit>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Unit>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Unit>().testLabel(_self, vm, label);
 }
 
 inline
-bool  TypedRichNode<Unit>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Unit>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Unit>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Unit>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Unit>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Unit>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<Unit>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Unit>::getPrintName(mozart::VM vm) {
   return _self.access<Unit>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::isName(VM vm) {
+bool  TypedRichNode<Unit>::isName(mozart::VM vm) {
   return _self.access<Unit>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Unit>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Unit>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<Unit>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Unit>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Unit>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/VMPort-implem-decl-after.hh b/vm/boostenv/main/cached/VMPort-implem-decl-after.hh
index b55912ad8..df62e57b0 100644
--- a/vm/boostenv/main/cached/VMPort-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/VMPort-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<VMPort>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("VMPort", uuid(), (! ::mozart::MemWord::requiresExternalMemory<VMIdentifier>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("VMPort", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::VMIdentifier>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<VMPort>* const instance() {
     return &RawType<VMPort>::rawType;
@@ -42,20 +42,20 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  VMIdentifier value();
+  mozart::VMIdentifier value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isPort(VM vm);
+  bool isPort(mozart::VM vm);
 
   inline
-  void send(VM vm, class mozart::RichNode value);
+  void send(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode sendReceive(VM vm, class mozart::RichNode value);
+  mozart::UnstableNode sendReceive(mozart::VM vm, mozart::RichNode value);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/VMPort-implem-decl.hh b/vm/boostenv/main/cached/VMPort-implem-decl.hh
index 3b8e85609..ae4e9a15b 100644
--- a/vm/boostenv/main/cached/VMPort-implem-decl.hh
+++ b/vm/boostenv/main/cached/VMPort-implem-decl.hh
@@ -3,5 +3,5 @@ class VMPort;
 template <>
 class Storage<VMPort> {
 public:
-  typedef VMIdentifier Type;
+  typedef mozart::VMIdentifier Type;
 };
diff --git a/vm/boostenv/main/cached/VMPort-implem.hh b/vm/boostenv/main/cached/VMPort-implem.hh
index a092e4131..d871bdbe0 100644
--- a/vm/boostenv/main/cached/VMPort-implem.hh
+++ b/vm/boostenv/main/cached/VMPort-implem.hh
@@ -26,31 +26,31 @@ void TypeInfoOf<VMPort>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-VMIdentifier  TypedRichNode<VMPort>::value() {
+mozart::VMIdentifier  TypedRichNode<VMPort>::value() {
   return _self.access<VMPort>().value();
 }
 
 inline
-bool  TypedRichNode<VMPort>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<VMPort>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<VMPort>().equals(vm, right);
 }
 
 inline
-bool  TypedRichNode<VMPort>::isPort(VM vm) {
+bool  TypedRichNode<VMPort>::isPort(mozart::VM vm) {
   return _self.access<VMPort>().isPort(vm);
 }
 
 inline
-void  TypedRichNode<VMPort>::send(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<VMPort>::send(mozart::VM vm, mozart::RichNode value) {
   _self.access<VMPort>().send(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<VMPort>::sendReceive(VM vm, class mozart::RichNode value) {
+mozart::UnstableNode  TypedRichNode<VMPort>::sendReceive(mozart::VM vm, mozart::RichNode value) {
   return _self.access<VMPort>().sendReceive(vm, value);
 }
 
 inline
-void  TypedRichNode<VMPort>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<VMPort>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<VMPort>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/ValueEquatable-interf.hh b/vm/boostenv/main/cached/ValueEquatable-interf.hh
index 52afd20d6..548c5062e 100644
--- a/vm/boostenv/main/cached/ValueEquatable-interf.hh
+++ b/vm/boostenv/main/cached/ValueEquatable-interf.hh
@@ -4,7 +4,7 @@ public:
   ValueEquatable(UnstableNode& self) : _self(self) {}
   ValueEquatable(StableNode& self) : _self(self) {}
 
-  bool equals(VM vm, class mozart::RichNode right) {
+  bool equals(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().equals(vm, right);
     } else if (_self.is<BigInt>()) {
diff --git a/vm/boostenv/main/cached/Variable-implem-decl-after.hh b/vm/boostenv/main/cached/Variable-implem-decl-after.hh
index f87779f6e..2e888e68b 100644
--- a/vm/boostenv/main/cached/Variable-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/Variable-implem-decl-after.hh
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void wakeUp(VM vm);
+  void wakeUp(mozart::VM vm);
 
   inline
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space);
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Variable-implem.hh b/vm/boostenv/main/cached/Variable-implem.hh
index 1d71d6676..73cf01dda 100644
--- a/vm/boostenv/main/cached/Variable-implem.hh
+++ b/vm/boostenv/main/cached/Variable-implem.hh
@@ -26,41 +26,41 @@ void TypeInfoOf<Variable>::sClone(SC sc, RichNode from, UnstableNode& to) const
 }
 
 inline
-class mozart::Space *  TypedRichNode<Variable>::home() {
+mozart::Space *  TypedRichNode<Variable>::home() {
   return _self.access<Variable>().home();
 }
 
 inline
-void  TypedRichNode<Variable>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<Variable>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<Variable>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<Variable>::isNeeded(VM vm) {
+bool  TypedRichNode<Variable>::isNeeded(mozart::VM vm) {
   return _self.access<Variable>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<Variable>::markNeeded(VM vm) {
+void  TypedRichNode<Variable>::markNeeded(mozart::VM vm) {
   _self.access<Variable>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<Variable>::wakeUp(VM vm) {
+void  TypedRichNode<Variable>::wakeUp(mozart::VM vm) {
   _self.access<Variable>().wakeUp(_self, vm);
 }
 
 inline
-bool  TypedRichNode<Variable>::shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+bool  TypedRichNode<Variable>::shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
   return _self.access<Variable>().shouldWakeUpUnderSpace(vm, space);
 }
 
 inline
-void  TypedRichNode<Variable>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<Variable>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<Variable>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<Variable>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Variable>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Variable>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/boostenv/main/cached/Wakeable-interf.hh b/vm/boostenv/main/cached/Wakeable-interf.hh
index 087dbf17a..b6df799ce 100644
--- a/vm/boostenv/main/cached/Wakeable-interf.hh
+++ b/vm/boostenv/main/cached/Wakeable-interf.hh
@@ -4,7 +4,7 @@ public:
   Wakeable(UnstableNode& self) : _self(self) {}
   Wakeable(StableNode& self) : _self(self) {}
 
-  void wakeUp(VM vm) {
+  void wakeUp(mozart::VM vm) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().wakeUp(vm);
     } else if (_self.is<Variable>()) {
@@ -16,7 +16,7 @@ public:
     }
   }
 
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().shouldWakeUpUnderSpace(vm, space);
     } else if (_self.is<Variable>()) {
diff --git a/vm/boostenv/main/cached/WeakReference-implem-decl-after.hh b/vm/boostenv/main/cached/WeakReference-implem-decl-after.hh
index 37ab624c3..cc71e5afa 100644
--- a/vm/boostenv/main/cached/WeakReference-implem-decl-after.hh
+++ b/vm/boostenv/main/cached/WeakReference-implem-decl-after.hh
@@ -34,5 +34,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 };
diff --git a/vm/boostenv/main/cached/WeakReference-implem-decl.hh b/vm/boostenv/main/cached/WeakReference-implem-decl.hh
index 5f368840a..e5d4be79d 100644
--- a/vm/boostenv/main/cached/WeakReference-implem-decl.hh
+++ b/vm/boostenv/main/cached/WeakReference-implem-decl.hh
@@ -3,5 +3,5 @@ class WeakReference;
 template <>
 class Storage<WeakReference> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/boostenv/main/cached/WeakReference-implem.hh b/vm/boostenv/main/cached/WeakReference-implem.hh
index 137598365..28d74518f 100644
--- a/vm/boostenv/main/cached/WeakReference-implem.hh
+++ b/vm/boostenv/main/cached/WeakReference-implem.hh
@@ -6,9 +6,7 @@ void TypeInfoOf<WeakReference>::gCollect(GC gc, RichNode from, StableNode& to) c
 
 void TypeInfoOf<WeakReference>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<WeakReference>(gc->vm, gc, from.access<WeakReference>());
+  to.make<WeakReference>(gc->vm, gc, from.access<WeakReference>());
 }
 
 void TypeInfoOf<WeakReference>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -22,6 +20,6 @@ void TypeInfoOf<WeakReference>::sClone(SC sc, RichNode from, UnstableNode& to) c
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<WeakReference>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<WeakReference>::getUnderlying() {
   return _self.access<WeakReference>().getUnderlying();
 }
diff --git a/vm/boostenv/main/cached/WithPrintName-interf.hh b/vm/boostenv/main/cached/WithPrintName-interf.hh
index 6eb844d41..07f7304a9 100644
--- a/vm/boostenv/main/cached/WithPrintName-interf.hh
+++ b/vm/boostenv/main/cached/WithPrintName-interf.hh
@@ -4,7 +4,7 @@ public:
   WithPrintName(UnstableNode& self) : _self(self) {}
   WithPrintName(StableNode& self) : _self(self) {}
 
-  atom_t getPrintName(VM vm) {
+  mozart::atom_t getPrintName(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().getPrintName(vm);
     } else if (_self.is<BuiltinProcedure>()) {
@@ -21,7 +21,7 @@ public:
       return _self.as<Unit>().getPrintName(vm);
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        atom_t _result;
+        mozart::atom_t _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::WithPrintName::getPrintName", "getPrintName", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/generator/main/builtins.cc b/vm/generator/main/builtins.cc
index ac29863c6..53b30433a 100644
--- a/vm/generator/main/builtins.cc
+++ b/vm/generator/main/builtins.cc
@@ -147,12 +147,14 @@ void processBuiltinCallMethod(BuiltinDef& definition,
 
     std::string paramType = param->getType().getAsString();
 
-    if (paramType == "In")
+    if (paramType == "mozart::builtins::In") {
       paramDef.kind = pkIn;
-    else if (paramType == "Out")
+    } else if (paramType == "mozart::builtins::Out") {
       paramDef.kind = pkOut;
-    else
+    } else {
+      std::cerr << "Invalid parameter type: " << paramType << " in " << method->getNameAsString() << std::endl;
       assert(false);
+    }
 
     paramDef.name = param->getNameAsString();
 
diff --git a/vm/generator/main/generator.cc b/vm/generator/main/generator.cc
index b9a9a67ec..0e3c33593 100644
--- a/vm/generator/main/generator.cc
+++ b/vm/generator/main/generator.cc
@@ -109,6 +109,7 @@ int main(int argc, char* argv[]) {
   std::unique_ptr<ASTUnit> unit =
       ASTUnit::LoadFromASTFile(astFile,
                                CI.getPCHContainerReader(),
+                               clang::ASTUnit::WhatToLoad::LoadASTOnly,
                                Diags,
                                CI.getFileSystemOpts());
 
diff --git a/vm/vm/main/cached/Abstraction-implem-decl-after.hh b/vm/vm/main/cached/Abstraction-implem-decl-after.hh
index f1e5c94d2..b4c4994a7 100644
--- a/vm/vm/main/cached/Abstraction-implem-decl-after.hh
+++ b/vm/vm/main/cached/Abstraction-implem-decl-after.hh
@@ -51,44 +51,44 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void setUUID(VM vm, const struct mozart::UUID & uuid);
+  void setUUID(mozart::VM vm, const mozart::UUID & uuid);
 };
diff --git a/vm/vm/main/cached/Abstraction-implem-decl.hh b/vm/vm/main/cached/Abstraction-implem-decl.hh
index 5253c6a09..2ee7301e8 100644
--- a/vm/vm/main/cached/Abstraction-implem-decl.hh
+++ b/vm/vm/main/cached/Abstraction-implem-decl.hh
@@ -3,5 +3,5 @@ class Abstraction;
 template <>
 class Storage<Abstraction> {
 public:
-  typedef ImplWithArray<Abstraction, class mozart::StableNode> Type;
+  typedef ImplWithArray<Abstraction, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/Abstraction-implem.hh b/vm/vm/main/cached/Abstraction-implem.hh
index 737474ce8..87fe9ffba 100644
--- a/vm/vm/main/cached/Abstraction-implem.hh
+++ b/vm/vm/main/cached/Abstraction-implem.hh
@@ -47,16 +47,16 @@ size_t TypedRichNode<Abstraction>::getArraySize() {
   return _self.access<Abstraction>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Abstraction>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Abstraction>::getElementsArray() {
   return _self.access<Abstraction>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Abstraction>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Abstraction>::getElements(size_t i) {
   return _self.access<Abstraction>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Abstraction>::home() {
+mozart::Space *  TypedRichNode<Abstraction>::home() {
   return _self.access<Abstraction>().home();
 }
 
@@ -66,51 +66,51 @@ size_t  TypedRichNode<Abstraction>::getArraySizeImpl() {
 }
 
 inline
-atom_t  TypedRichNode<Abstraction>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Abstraction>::getPrintName(mozart::VM vm) {
   return _self.access<Abstraction>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Abstraction>::isCallable(VM vm) {
+bool  TypedRichNode<Abstraction>::isCallable(mozart::VM vm) {
   return _self.access<Abstraction>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<Abstraction>::isProcedure(VM vm) {
+bool  TypedRichNode<Abstraction>::isProcedure(mozart::VM vm) {
   return _self.access<Abstraction>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<Abstraction>::procedureArity(VM vm) {
+size_t  TypedRichNode<Abstraction>::procedureArity(mozart::VM vm) {
   return _self.access<Abstraction>().procedureArity(vm);
 }
 
 inline
-void  TypedRichNode<Abstraction>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<Abstraction>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<Abstraction>().getCallInfo(vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<Abstraction>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<Abstraction>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<Abstraction>().getDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<Abstraction>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Abstraction>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Abstraction>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Abstraction>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Abstraction>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Abstraction>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<Abstraction>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<Abstraction>::globalize(mozart::VM vm) {
   return _self.access<Abstraction>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<Abstraction>::setUUID(VM vm, const struct mozart::UUID & uuid) {
+void  TypedRichNode<Abstraction>::setUUID(mozart::VM vm, const mozart::UUID & uuid) {
   _self.access<Abstraction>().setUUID(_self, vm, uuid);
 }
diff --git a/vm/vm/main/cached/Arity-implem-decl-after.hh b/vm/vm/main/cached/Arity-implem-decl-after.hh
index d7b8bc912..bd95ec320 100644
--- a/vm/vm/main/cached/Arity-implem-decl-after.hh
+++ b/vm/vm/main/cached/Arity-implem-decl-after.hh
@@ -48,32 +48,32 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getLabel();
+  mozart::StableNode * getLabel();
 
   inline
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, size_t & offset);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, size_t & offset);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/Arity-implem-decl.hh b/vm/vm/main/cached/Arity-implem-decl.hh
index 593265840..0cb720eae 100644
--- a/vm/vm/main/cached/Arity-implem-decl.hh
+++ b/vm/vm/main/cached/Arity-implem-decl.hh
@@ -3,5 +3,5 @@ class Arity;
 template <>
 class Storage<Arity> {
 public:
-  typedef ImplWithArray<Arity, class mozart::StableNode> Type;
+  typedef ImplWithArray<Arity, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/Arity-implem.hh b/vm/vm/main/cached/Arity-implem.hh
index 72f71a9dc..a59488bb4 100644
--- a/vm/vm/main/cached/Arity-implem.hh
+++ b/vm/vm/main/cached/Arity-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Arity>::getArraySize() {
   return _self.access<Arity>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Arity>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Arity>::getElementsArray() {
   return _self.access<Arity>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Arity>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Arity>::getElements(size_t i) {
   return _self.access<Arity>().getElements(i);
 }
 
@@ -48,7 +48,7 @@ size_t  TypedRichNode<Arity>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Arity>::getLabel() {
+mozart::StableNode *  TypedRichNode<Arity>::getLabel() {
   return _self.access<Arity>().getLabel();
 }
 
@@ -58,26 +58,26 @@ size_t  TypedRichNode<Arity>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Arity>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Arity>::getElement(size_t index) {
   return _self.access<Arity>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Arity>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Arity>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Arity>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Arity>::lookupFeature(VM vm, class mozart::RichNode feature, size_t & offset) {
+bool  TypedRichNode<Arity>::lookupFeature(mozart::VM vm, mozart::RichNode feature, size_t & offset) {
   return _self.access<Arity>().lookupFeature(vm, feature, offset);
 }
 
 inline
-void  TypedRichNode<Arity>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Arity>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Arity>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Arity>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Arity>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Arity>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/Array-implem-decl-after.hh b/vm/vm/main/cached/Array-implem-decl-after.hh
index 087d435fb..ea0066def 100644
--- a/vm/vm/main/cached/Array-implem-decl-after.hh
+++ b/vm/vm/main/cached/Array-implem-decl-after.hh
@@ -45,19 +45,19 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::UnstableNode> getElementsArray();
+  StaticArray<mozart::UnstableNode> getElementsArray();
 
   inline
-  class mozart::UnstableNode& getElements(size_t i);
+  mozart::UnstableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
   size_t getArraySizeImpl();
@@ -66,35 +66,35 @@ public:
   size_t getWidth();
 
   inline
-  nativeint getLow();
+  mozart::nativeint getLow();
 
   inline
-  nativeint getHigh();
+  mozart::nativeint getHigh();
 
   inline
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  bool isArray(VM vm);
+  bool isArray(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayLow(VM vm);
+  mozart::UnstableNode arrayLow(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayHigh(VM vm);
+  mozart::UnstableNode arrayHigh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayGet(VM vm, class mozart::RichNode index);
+  mozart::UnstableNode arrayGet(mozart::VM vm, mozart::RichNode index);
 
   inline
-  void arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value);
+  void arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue);
+  mozart::UnstableNode arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Array-implem-decl.hh b/vm/vm/main/cached/Array-implem-decl.hh
index 8f404ef0c..2261a660b 100644
--- a/vm/vm/main/cached/Array-implem-decl.hh
+++ b/vm/vm/main/cached/Array-implem-decl.hh
@@ -3,5 +3,5 @@ class Array;
 template <>
 class Storage<Array> {
 public:
-  typedef ImplWithArray<Array, class mozart::UnstableNode> Type;
+  typedef ImplWithArray<Array, mozart::UnstableNode> Type;
 };
diff --git a/vm/vm/main/cached/Array-implem.hh b/vm/vm/main/cached/Array-implem.hh
index 44aee40ce..b31ba7d4e 100644
--- a/vm/vm/main/cached/Array-implem.hh
+++ b/vm/vm/main/cached/Array-implem.hh
@@ -37,26 +37,26 @@ size_t TypedRichNode<Array>::getArraySize() {
   return _self.access<Array>().getArraySize();
 }
 
-StaticArray<class mozart::UnstableNode> TypedRichNode<Array>::getElementsArray() {
+StaticArray<mozart::UnstableNode> TypedRichNode<Array>::getElementsArray() {
   return _self.access<Array>().getElementsArray();
 }
 
-class mozart::UnstableNode& TypedRichNode<Array>::getElements(size_t i) {
+mozart::UnstableNode& TypedRichNode<Array>::getElements(size_t i) {
   return _self.access<Array>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Array>::home() {
+mozart::Space *  TypedRichNode<Array>::home() {
   return _self.access<Array>().home();
 }
 
 inline
-bool  TypedRichNode<Array>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Array>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Array>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Array>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Array>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Array>().lookupFeature(vm, feature, value);
 }
 
@@ -71,56 +71,56 @@ size_t  TypedRichNode<Array>::getWidth() {
 }
 
 inline
-nativeint  TypedRichNode<Array>::getLow() {
+mozart::nativeint  TypedRichNode<Array>::getLow() {
   return _self.access<Array>().getLow();
 }
 
 inline
-nativeint  TypedRichNode<Array>::getHigh() {
+mozart::nativeint  TypedRichNode<Array>::getHigh() {
   return _self.access<Array>().getHigh();
 }
 
 inline
-void  TypedRichNode<Array>::dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+void  TypedRichNode<Array>::dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   _self.access<Array>().dotAssign(_self, vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Array>::dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   return _self.access<Array>().dotExchange(_self, vm, feature, newValue);
 }
 
 inline
-bool  TypedRichNode<Array>::isArray(VM vm) {
+bool  TypedRichNode<Array>::isArray(mozart::VM vm) {
   return _self.access<Array>().isArray(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayLow(VM vm) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayLow(mozart::VM vm) {
   return _self.access<Array>().arrayLow(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayHigh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayHigh(mozart::VM vm) {
   return _self.access<Array>().arrayHigh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayGet(VM vm, class mozart::RichNode index) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayGet(mozart::VM vm, mozart::RichNode index) {
   return _self.access<Array>().arrayGet(_self, vm, index);
 }
 
 inline
-void  TypedRichNode<Array>::arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value) {
+void  TypedRichNode<Array>::arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value) {
   _self.access<Array>().arrayPut(_self, vm, index, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Array>::arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Array>::arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue) {
   return _self.access<Array>().arrayExchange(_self, vm, index, newValue);
 }
 
 inline
-void  TypedRichNode<Array>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Array>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Array>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ArrayLike-interf.hh b/vm/vm/main/cached/ArrayLike-interf.hh
index 8cb1a58c8..ddc0c15e0 100644
--- a/vm/vm/main/cached/ArrayLike-interf.hh
+++ b/vm/vm/main/cached/ArrayLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ArrayLike(UnstableNode& self) : _self(self) {}
   ArrayLike(StableNode& self) : _self(self) {}
 
-  bool isArray(VM vm) {
+  bool isArray(mozart::VM vm) {
     if (_self.is<Array>()) {
       return _self.as<Array>().isArray(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayLow(VM vm) {
+  mozart::UnstableNode arrayLow(mozart::VM vm) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayLow(vm);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayLow", "arrayLow", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayHigh(VM vm) {
+  mozart::UnstableNode arrayHigh(mozart::VM vm) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayHigh(vm);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayHigh", "arrayHigh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayGet(VM vm, class mozart::RichNode index) {
+  mozart::UnstableNode arrayGet(mozart::VM vm, mozart::RichNode index) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayGet(vm, index);
     } else if (_self.isTransient()) {
@@ -60,7 +60,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayGet", "arrayGet", index, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -68,7 +68,7 @@ public:
     }
   }
 
-  void arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value) {
+  void arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayPut(vm, index, value);
     } else if (_self.isTransient()) {
@@ -83,7 +83,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue) {
+  mozart::UnstableNode arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue) {
     if (_self.is<Array>()) {
       return _self.as<Array>().arrayExchange(vm, index, newValue);
     } else if (_self.isTransient()) {
@@ -91,7 +91,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ArrayLike::arrayExchange", "arrayExchange", index, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/Atom-implem-decl-after.hh b/vm/vm/main/cached/Atom-implem-decl-after.hh
index e23cdf9da..eb584aed1 100644
--- a/vm/vm/main/cached/Atom-implem-decl-after.hh
+++ b/vm/vm/main/cached/Atom-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<Atom>: public TypeInfo {
     return Atom::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("Atom", uuid(), (! ::mozart::MemWord::requiresExternalMemory<atom_t>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("Atom", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::atom_t>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<Atom>* const instance() {
     return &RawType<Atom>::rawType;
@@ -45,62 +45,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  atom_t value();
+  mozart::atom_t value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isAtom(VM vm);
+  bool isAtom(mozart::VM vm);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Atom-implem-decl.hh b/vm/vm/main/cached/Atom-implem-decl.hh
index 6d1f61198..fb03ec7ab 100644
--- a/vm/vm/main/cached/Atom-implem-decl.hh
+++ b/vm/vm/main/cached/Atom-implem-decl.hh
@@ -3,5 +3,5 @@ class Atom;
 template <>
 class Storage<Atom> {
 public:
-  typedef atom_t Type;
+  typedef mozart::atom_t Type;
 };
diff --git a/vm/vm/main/cached/Atom-implem.hh b/vm/vm/main/cached/Atom-implem.hh
index 9a0fe772e..bbcbed493 100644
--- a/vm/vm/main/cached/Atom-implem.hh
+++ b/vm/vm/main/cached/Atom-implem.hh
@@ -31,101 +31,101 @@ int TypeInfoOf<Atom>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) const {
 
 
 inline
-bool  TypedRichNode<Atom>::isLiteral(VM vm) {
+bool  TypedRichNode<Atom>::isLiteral(mozart::VM vm) {
   return _self.access<Atom>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Atom>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Atom>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Atom>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Atom>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Atom>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Atom>::isRecord(VM vm) {
+bool  TypedRichNode<Atom>::isRecord(mozart::VM vm) {
   return _self.access<Atom>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::isTuple(VM vm) {
+bool  TypedRichNode<Atom>::isTuple(mozart::VM vm) {
   return _self.access<Atom>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::label(mozart::VM vm) {
   return _self.access<Atom>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<Atom>::width(VM vm) {
+size_t  TypedRichNode<Atom>::width(mozart::VM vm) {
   return _self.access<Atom>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::arityList(mozart::VM vm) {
   return _self.access<Atom>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::clone(mozart::VM vm) {
   return _self.access<Atom>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Atom>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Atom>::waitOr(mozart::VM vm) {
   return _self.access<Atom>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Atom>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Atom>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Atom>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Atom>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Atom>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Atom>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Atom>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Atom>().testLabel(_self, vm, label);
 }
 
 inline
-atom_t  TypedRichNode<Atom>::value() {
+mozart::atom_t  TypedRichNode<Atom>::value() {
   return _self.access<Atom>().value();
 }
 
 inline
-bool  TypedRichNode<Atom>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Atom>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Atom>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Atom>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Atom>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Atom>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<Atom>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Atom>::getPrintName(mozart::VM vm) {
   return _self.access<Atom>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Atom>::isAtom(VM vm) {
+bool  TypedRichNode<Atom>::isAtom(mozart::VM vm) {
   return _self.access<Atom>().isAtom(vm);
 }
 
 inline
-int  TypedRichNode<Atom>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Atom>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Atom>().compare(vm, right);
 }
 
 inline
-void  TypedRichNode<Atom>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Atom>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Atom>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/AtomLike-interf.hh b/vm/vm/main/cached/AtomLike-interf.hh
index 9dc552154..a5fbfd797 100644
--- a/vm/vm/main/cached/AtomLike-interf.hh
+++ b/vm/vm/main/cached/AtomLike-interf.hh
@@ -4,7 +4,7 @@ public:
   AtomLike(UnstableNode& self) : _self(self) {}
   AtomLike(StableNode& self) : _self(self) {}
 
-  bool isAtom(VM vm) {
+  bool isAtom(mozart::VM vm) {
     if (_self.is<Atom>()) {
       return _self.as<Atom>().isAtom(vm);
     } else if (_self.isTransient()) {
diff --git a/vm/vm/main/cached/BaseDottable-interf.hh b/vm/vm/main/cached/BaseDottable-interf.hh
index 1fa125a11..ae2ab6e88 100644
--- a/vm/vm/main/cached/BaseDottable-interf.hh
+++ b/vm/vm/main/cached/BaseDottable-interf.hh
@@ -4,7 +4,7 @@ public:
   BaseDottable(UnstableNode& self) : _self(self) {}
   BaseDottable(StableNode& self) : _self(self) {}
 
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().lookupFeature(vm, feature, value);
     } else if (_self.is<Record>()) {
@@ -42,7 +42,7 @@ public:
     }
   }
 
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().lookupFeature(vm, feature, value);
     } else if (_self.is<Record>()) {
diff --git a/vm/vm/main/cached/BigInt-implem-decl-after.hh b/vm/vm/main/cached/BigInt-implem-decl-after.hh
index 88f966a71..c2be2e6da 100644
--- a/vm/vm/main/cached/BigInt-implem-decl-after.hh
+++ b/vm/vm/main/cached/BigInt-implem-decl-after.hh
@@ -48,46 +48,46 @@ public:
   std::shared_ptr<BigIntImplem> value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isNumber(VM vm);
+  bool isNumber(mozart::VM vm);
 
   inline
-  bool isInt(VM vm);
+  bool isInt(mozart::VM vm);
 
   inline
-  bool isFloat(VM vm);
+  bool isFloat(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode opposite(VM vm);
+  mozart::UnstableNode opposite(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode add(VM vm, nativeint b);
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode abs(VM vm);
+  mozart::UnstableNode abs(mozart::VM vm);
 
   inline
   double doubleValue();
@@ -96,5 +96,5 @@ public:
   std::string str();
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/BigInt-implem.hh b/vm/vm/main/cached/BigInt-implem.hh
index 77be62db4..dd692c65a 100644
--- a/vm/vm/main/cached/BigInt-implem.hh
+++ b/vm/vm/main/cached/BigInt-implem.hh
@@ -36,72 +36,72 @@ std::shared_ptr<BigIntImplem>  TypedRichNode<BigInt>::value() {
 }
 
 inline
-bool  TypedRichNode<BigInt>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<BigInt>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<BigInt>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<BigInt>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().compareFeatures(vm, right);
 }
 
 inline
-int  TypedRichNode<BigInt>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<BigInt>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<BigInt>::isNumber(VM vm) {
+bool  TypedRichNode<BigInt>::isNumber(mozart::VM vm) {
   return _self.access<BigInt>().isNumber(vm);
 }
 
 inline
-bool  TypedRichNode<BigInt>::isInt(VM vm) {
+bool  TypedRichNode<BigInt>::isInt(mozart::VM vm) {
   return _self.access<BigInt>().isInt(vm);
 }
 
 inline
-bool  TypedRichNode<BigInt>::isFloat(VM vm) {
+bool  TypedRichNode<BigInt>::isFloat(mozart::VM vm) {
   return _self.access<BigInt>().isFloat(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::opposite(VM vm) {
+mozart::UnstableNode  TypedRichNode<BigInt>::opposite(mozart::VM vm) {
   return _self.access<BigInt>().opposite(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::add(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::add(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().add(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::add(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<BigInt>::add(mozart::VM vm, mozart::nativeint b) {
   return _self.access<BigInt>().add(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::subtract(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::subtract(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().subtract(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::multiply(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::multiply(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().multiply(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::div(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::div(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().div(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::mod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<BigInt>::mod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BigInt>().mod(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BigInt>::abs(VM vm) {
+mozart::UnstableNode  TypedRichNode<BigInt>::abs(mozart::VM vm) {
   return _self.access<BigInt>().abs(_self, vm);
 }
 
@@ -116,6 +116,6 @@ std::string  TypedRichNode<BigInt>::str() {
 }
 
 inline
-void  TypedRichNode<BigInt>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<BigInt>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<BigInt>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/BindableReadOnly-interf.hh b/vm/vm/main/cached/BindableReadOnly-interf.hh
index 7bfbff94b..c743f624f 100644
--- a/vm/vm/main/cached/BindableReadOnly-interf.hh
+++ b/vm/vm/main/cached/BindableReadOnly-interf.hh
@@ -4,7 +4,7 @@ public:
   BindableReadOnly(UnstableNode& self) : _self(self) {}
   BindableReadOnly(StableNode& self) : _self(self) {}
 
-  void bindReadOnly(VM vm, class mozart::RichNode src) {
+  void bindReadOnly(mozart::VM vm, mozart::RichNode src) {
     if (_self.is<ReadOnlyVariable>()) {
       return _self.as<ReadOnlyVariable>().bindReadOnly(vm, src);
     } else if (_self.is<ReflectiveVariable>()) {
diff --git a/vm/vm/main/cached/Boolean-implem-decl-after.hh b/vm/vm/main/cached/Boolean-implem-decl-after.hh
index da2839d89..00ae58fd4 100644
--- a/vm/vm/main/cached/Boolean-implem-decl-after.hh
+++ b/vm/vm/main/cached/Boolean-implem-decl-after.hh
@@ -48,62 +48,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
   bool value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Boolean-implem.hh b/vm/vm/main/cached/Boolean-implem.hh
index 049da9504..2bbba4002 100644
--- a/vm/vm/main/cached/Boolean-implem.hh
+++ b/vm/vm/main/cached/Boolean-implem.hh
@@ -36,67 +36,67 @@ int TypeInfoOf<Boolean>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) cons
 
 
 inline
-bool  TypedRichNode<Boolean>::isLiteral(VM vm) {
+bool  TypedRichNode<Boolean>::isLiteral(mozart::VM vm) {
   return _self.access<Boolean>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Boolean>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Boolean>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Boolean>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Boolean>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Boolean>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Boolean>::isRecord(VM vm) {
+bool  TypedRichNode<Boolean>::isRecord(mozart::VM vm) {
   return _self.access<Boolean>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::isTuple(VM vm) {
+bool  TypedRichNode<Boolean>::isTuple(mozart::VM vm) {
   return _self.access<Boolean>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::label(mozart::VM vm) {
   return _self.access<Boolean>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<Boolean>::width(VM vm) {
+size_t  TypedRichNode<Boolean>::width(mozart::VM vm) {
   return _self.access<Boolean>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::arityList(mozart::VM vm) {
   return _self.access<Boolean>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::clone(mozart::VM vm) {
   return _self.access<Boolean>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Boolean>::waitOr(mozart::VM vm) {
   return _self.access<Boolean>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Boolean>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Boolean>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Boolean>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Boolean>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Boolean>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Boolean>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Boolean>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Boolean>().testLabel(_self, vm, label);
 }
 
@@ -106,31 +106,31 @@ bool  TypedRichNode<Boolean>::value() {
 }
 
 inline
-bool  TypedRichNode<Boolean>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Boolean>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Boolean>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Boolean>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Boolean>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Boolean>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<Boolean>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Boolean>::getPrintName(mozart::VM vm) {
   return _self.access<Boolean>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Boolean>::isName(VM vm) {
+bool  TypedRichNode<Boolean>::isName(mozart::VM vm) {
   return _self.access<Boolean>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Boolean>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Boolean>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Boolean>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<Boolean>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Boolean>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Boolean>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/BuiltinCallable-interf.hh b/vm/vm/main/cached/BuiltinCallable-interf.hh
index 6de15bc8b..a74f5b166 100644
--- a/vm/vm/main/cached/BuiltinCallable-interf.hh
+++ b/vm/vm/main/cached/BuiltinCallable-interf.hh
@@ -4,7 +4,7 @@ public:
   BuiltinCallable(UnstableNode& self) : _self(self) {}
   BuiltinCallable(StableNode& self) : _self(self) {}
 
-  bool isBuiltin(VM vm) {
+  bool isBuiltin(mozart::VM vm) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().isBuiltin(vm);
     } else if (_self.isTransient()) {
@@ -15,7 +15,7 @@ public:
     }
   }
 
-  void callBuiltin(VM vm, size_t argc, class mozart::UnstableNode ** args) {
+  void callBuiltin(mozart::VM vm, size_t argc, mozart::UnstableNode ** args) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().callBuiltin(vm, argc, args);
     } else if (_self.isTransient()) {
@@ -27,7 +27,7 @@ public:
   }
 
   template <class ... Args> 
-  void callBuiltin(VM vm, Args &&... args) {
+  void callBuiltin(mozart::VM vm, Args &&... args) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().callBuiltin(vm, std::forward<Args>(args)...);
     } else if (_self.isTransient()) {
@@ -38,7 +38,7 @@ public:
     }
   }
 
-  builtins::BaseBuiltin * getBuiltin(VM vm) {
+  builtins::BaseBuiltin * getBuiltin(mozart::VM vm) {
     if (_self.is<BuiltinProcedure>()) {
       return _self.as<BuiltinProcedure>().getBuiltin(vm);
     } else if (_self.isTransient()) {
diff --git a/vm/vm/main/cached/BuiltinProcedure-implem-decl-after.hh b/vm/vm/main/cached/BuiltinProcedure-implem-decl-after.hh
index b662bedfb..d34235333 100644
--- a/vm/vm/main/cached/BuiltinProcedure-implem-decl-after.hh
+++ b/vm/vm/main/cached/BuiltinProcedure-implem-decl-after.hh
@@ -51,42 +51,42 @@ public:
   size_t getArity();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isBuiltin(VM vm);
+  bool isBuiltin(mozart::VM vm);
 
   inline
-  void callBuiltin(VM vm, size_t argc, class mozart::UnstableNode ** args);
+  void callBuiltin(mozart::VM vm, size_t argc, mozart::UnstableNode ** args);
 
   template <class ... Args> 
   inline
-  void callBuiltin(VM vm, Args &&... args);
+  void callBuiltin(mozart::VM vm, Args &&... args);
 
   inline
-  builtins::BaseBuiltin * getBuiltin(VM vm);
+  builtins::BaseBuiltin * getBuiltin(mozart::VM vm);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/BuiltinProcedure-implem.hh b/vm/vm/main/cached/BuiltinProcedure-implem.hh
index 83160da7c..8dd2dbc83 100644
--- a/vm/vm/main/cached/BuiltinProcedure-implem.hh
+++ b/vm/vm/main/cached/BuiltinProcedure-implem.hh
@@ -41,67 +41,67 @@ size_t  TypedRichNode<BuiltinProcedure>::getArity() {
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<BuiltinProcedure>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<BuiltinProcedure>().equals(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<BuiltinProcedure>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<BuiltinProcedure>::getPrintName(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::isBuiltin(VM vm) {
+bool  TypedRichNode<BuiltinProcedure>::isBuiltin(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().isBuiltin(vm);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::callBuiltin(VM vm, size_t argc, class mozart::UnstableNode ** args) {
+void  TypedRichNode<BuiltinProcedure>::callBuiltin(mozart::VM vm, size_t argc, mozart::UnstableNode ** args) {
   _self.access<BuiltinProcedure>().callBuiltin(vm, argc, args);
 }
 
 template <class ... Args> 
 inline
-void  TypedRichNode<BuiltinProcedure>::callBuiltin(VM vm, Args &&... args) {
+void  TypedRichNode<BuiltinProcedure>::callBuiltin(mozart::VM vm, Args &&... args) {
   _self.access<BuiltinProcedure>().callBuiltin<Args... >(vm, std::forward<Args>(args)...);
 }
 
 inline
-builtins::BaseBuiltin *  TypedRichNode<BuiltinProcedure>::getBuiltin(VM vm) {
+builtins::BaseBuiltin *  TypedRichNode<BuiltinProcedure>::getBuiltin(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().getBuiltin(vm);
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::isCallable(VM vm) {
+bool  TypedRichNode<BuiltinProcedure>::isCallable(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<BuiltinProcedure>::isProcedure(VM vm) {
+bool  TypedRichNode<BuiltinProcedure>::isProcedure(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<BuiltinProcedure>::procedureArity(VM vm) {
+size_t  TypedRichNode<BuiltinProcedure>::procedureArity(mozart::VM vm) {
   return _self.access<BuiltinProcedure>().procedureArity(vm);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<BuiltinProcedure>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<BuiltinProcedure>().getCallInfo(_self, vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<BuiltinProcedure>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<BuiltinProcedure>().getDebugInfo(_self, vm, printName, debugData);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<BuiltinProcedure>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<BuiltinProcedure>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<BuiltinProcedure>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<BuiltinProcedure>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<BuiltinProcedure>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<BuiltinProcedure>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ByteString-implem-decl-after.hh b/vm/vm/main/cached/ByteString-implem-decl-after.hh
index b757fefb6..0ca48851e 100644
--- a/vm/vm/main/cached/ByteString-implem-decl-after.hh
+++ b/vm/vm/main/cached/ByteString-implem-decl-after.hh
@@ -42,50 +42,50 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
   const LString<unsigned char> & value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isString(VM vm);
+  bool isString(mozart::VM vm);
 
   inline
-  bool isByteString(VM vm);
+  bool isByteString(mozart::VM vm);
 
   inline
-  LString<char> * stringGet(VM vm);
+  LString<char> * stringGet(mozart::VM vm);
 
   inline
-  LString<unsigned char> * byteStringGet(VM vm);
+  LString<unsigned char> * byteStringGet(mozart::VM vm);
 
   inline
-  nativeint stringCharAt(VM vm, class mozart::RichNode offset);
+  mozart::nativeint stringCharAt(mozart::VM vm, mozart::RichNode offset);
 
   inline
-  class mozart::UnstableNode stringAppend(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode stringAppend(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to);
+  mozart::UnstableNode stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to);
 
   inline
-  void stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end);
+  void stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end);
 
   inline
-  bool stringHasPrefix(VM vm, class mozart::RichNode prefix);
+  bool stringHasPrefix(mozart::VM vm, mozart::RichNode prefix);
 
   inline
-  bool stringHasSuffix(VM vm, class mozart::RichNode suffix);
+  bool stringHasSuffix(mozart::VM vm, mozart::RichNode suffix);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/ByteString-implem.hh b/vm/vm/main/cached/ByteString-implem.hh
index 167ec8b38..eab291308 100644
--- a/vm/vm/main/cached/ByteString-implem.hh
+++ b/vm/vm/main/cached/ByteString-implem.hh
@@ -26,12 +26,12 @@ void TypeInfoOf<ByteString>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-bool  TypedRichNode<ByteString>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<ByteString>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<ByteString>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<ByteString>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<ByteString>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<ByteString>().lookupFeature(vm, feature, value);
 }
 
@@ -41,66 +41,66 @@ const LString<unsigned char> &  TypedRichNode<ByteString>::value() {
 }
 
 inline
-bool  TypedRichNode<ByteString>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<ByteString>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ByteString>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<ByteString>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<ByteString>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ByteString>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<ByteString>::isString(VM vm) {
+bool  TypedRichNode<ByteString>::isString(mozart::VM vm) {
   return _self.access<ByteString>().isString(vm);
 }
 
 inline
-bool  TypedRichNode<ByteString>::isByteString(VM vm) {
+bool  TypedRichNode<ByteString>::isByteString(mozart::VM vm) {
   return _self.access<ByteString>().isByteString(vm);
 }
 
 inline
-LString<char> *  TypedRichNode<ByteString>::stringGet(VM vm) {
+LString<char> *  TypedRichNode<ByteString>::stringGet(mozart::VM vm) {
   return _self.access<ByteString>().stringGet(_self, vm);
 }
 
 inline
-LString<unsigned char> *  TypedRichNode<ByteString>::byteStringGet(VM vm) {
+LString<unsigned char> *  TypedRichNode<ByteString>::byteStringGet(mozart::VM vm) {
   return _self.access<ByteString>().byteStringGet(vm);
 }
 
 inline
-nativeint  TypedRichNode<ByteString>::stringCharAt(VM vm, class mozart::RichNode offset) {
+mozart::nativeint  TypedRichNode<ByteString>::stringCharAt(mozart::VM vm, mozart::RichNode offset) {
   return _self.access<ByteString>().stringCharAt(_self, vm, offset);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ByteString>::stringAppend(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<ByteString>::stringAppend(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ByteString>().stringAppend(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ByteString>::stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to) {
+mozart::UnstableNode  TypedRichNode<ByteString>::stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to) {
   return _self.access<ByteString>().stringSlice(_self, vm, from, to);
 }
 
 inline
-void  TypedRichNode<ByteString>::stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end) {
+void  TypedRichNode<ByteString>::stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end) {
   _self.access<ByteString>().stringSearch(_self, vm, from, needle, begin, end);
 }
 
 inline
-bool  TypedRichNode<ByteString>::stringHasPrefix(VM vm, class mozart::RichNode prefix) {
+bool  TypedRichNode<ByteString>::stringHasPrefix(mozart::VM vm, mozart::RichNode prefix) {
   return _self.access<ByteString>().stringHasPrefix(vm, prefix);
 }
 
 inline
-bool  TypedRichNode<ByteString>::stringHasSuffix(VM vm, class mozart::RichNode suffix) {
+bool  TypedRichNode<ByteString>::stringHasSuffix(mozart::VM vm, mozart::RichNode suffix) {
   return _self.access<ByteString>().stringHasSuffix(vm, suffix);
 }
 
 inline
-void  TypedRichNode<ByteString>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ByteString>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ByteString>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Callable-interf.hh b/vm/vm/main/cached/Callable-interf.hh
index accdfc6fd..77cc77ce1 100644
--- a/vm/vm/main/cached/Callable-interf.hh
+++ b/vm/vm/main/cached/Callable-interf.hh
@@ -4,7 +4,7 @@ public:
   Callable(UnstableNode& self) : _self(self) {}
   Callable(StableNode& self) : _self(self) {}
 
-  bool isCallable(VM vm) {
+  bool isCallable(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().isCallable(vm);
     } else if (_self.is<Object>()) {
@@ -19,7 +19,7 @@ public:
     }
   }
 
-  bool isProcedure(VM vm) {
+  bool isProcedure(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().isProcedure(vm);
     } else if (_self.is<Object>()) {
@@ -34,7 +34,7 @@ public:
     }
   }
 
-  size_t procedureArity(VM vm) {
+  size_t procedureArity(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().procedureArity(vm);
     } else if (_self.is<Object>()) {
@@ -49,7 +49,7 @@ public:
     }
   }
 
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().getCallInfo(vm, arity, start, Xcount, Gs, Ks);
     } else if (_self.is<Object>()) {
@@ -64,7 +64,7 @@ public:
     }
   }
 
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().getDebugInfo(vm, printName, debugData);
     } else if (_self.is<Object>()) {
diff --git a/vm/vm/main/cached/Cell-implem-decl-after.hh b/vm/vm/main/cached/Cell-implem-decl-after.hh
index b808ef55c..680f9c4c5 100644
--- a/vm/vm/main/cached/Cell-implem-decl-after.hh
+++ b/vm/vm/main/cached/Cell-implem-decl-after.hh
@@ -42,20 +42,20 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isCell(VM vm);
+  bool isCell(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode exchange(VM vm, class mozart::RichNode newValue);
+  mozart::UnstableNode exchange(mozart::VM vm, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode access(VM vm);
+  mozart::UnstableNode access(mozart::VM vm);
 
   inline
-  void assign(VM vm, class mozart::RichNode newValue);
+  void assign(mozart::VM vm, mozart::RichNode newValue);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Cell-implem.hh b/vm/vm/main/cached/Cell-implem.hh
index 0ad5098ec..bb0291c91 100644
--- a/vm/vm/main/cached/Cell-implem.hh
+++ b/vm/vm/main/cached/Cell-implem.hh
@@ -34,31 +34,31 @@ void TypeInfoOf<Cell>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<Cell>::home() {
+mozart::Space *  TypedRichNode<Cell>::home() {
   return _self.access<Cell>().home();
 }
 
 inline
-bool  TypedRichNode<Cell>::isCell(VM vm) {
+bool  TypedRichNode<Cell>::isCell(mozart::VM vm) {
   return _self.access<Cell>().isCell(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cell>::exchange(VM vm, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Cell>::exchange(mozart::VM vm, mozart::RichNode newValue) {
   return _self.access<Cell>().exchange(vm, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cell>::access(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cell>::access(mozart::VM vm) {
   return _self.access<Cell>().access(vm);
 }
 
 inline
-void  TypedRichNode<Cell>::assign(VM vm, class mozart::RichNode newValue) {
+void  TypedRichNode<Cell>::assign(mozart::VM vm, mozart::RichNode newValue) {
   _self.access<Cell>().assign(vm, newValue);
 }
 
 inline
-void  TypedRichNode<Cell>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Cell>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Cell>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/CellLike-interf.hh b/vm/vm/main/cached/CellLike-interf.hh
index f4d12ee8d..9f25c74e7 100644
--- a/vm/vm/main/cached/CellLike-interf.hh
+++ b/vm/vm/main/cached/CellLike-interf.hh
@@ -4,7 +4,7 @@ public:
   CellLike(UnstableNode& self) : _self(self) {}
   CellLike(StableNode& self) : _self(self) {}
 
-  bool isCell(VM vm) {
+  bool isCell(mozart::VM vm) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().isCell(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode exchange(VM vm, class mozart::RichNode newValue) {
+  mozart::UnstableNode exchange(mozart::VM vm, mozart::RichNode newValue) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().exchange(vm, newValue);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::CellLike::exchange", "exchange", newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode access(VM vm) {
+  mozart::UnstableNode access(mozart::VM vm) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().access(vm);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::CellLike::access", "access", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  void assign(VM vm, class mozart::RichNode newValue) {
+  void assign(mozart::VM vm, mozart::RichNode newValue) {
     if (_self.is<Cell>()) {
       return _self.as<Cell>().assign(vm, newValue);
     } else if (_self.isTransient()) {
diff --git a/vm/vm/main/cached/Chunk-implem-decl-after.hh b/vm/vm/main/cached/Chunk-implem-decl-after.hh
index c77427ea4..31b86a485 100644
--- a/vm/vm/main/cached/Chunk-implem-decl-after.hh
+++ b/vm/vm/main/cached/Chunk-implem-decl-after.hh
@@ -45,20 +45,20 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isChunk(VM vm);
+  bool isChunk(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/Chunk-implem-decl.hh b/vm/vm/main/cached/Chunk-implem-decl.hh
index 13f291889..dfbf50345 100644
--- a/vm/vm/main/cached/Chunk-implem-decl.hh
+++ b/vm/vm/main/cached/Chunk-implem-decl.hh
@@ -3,5 +3,5 @@ class Chunk;
 template <>
 class Storage<Chunk> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/vm/main/cached/Chunk-implem.hh b/vm/vm/main/cached/Chunk-implem.hh
index 7e58f9250..2b38e0e46 100644
--- a/vm/vm/main/cached/Chunk-implem.hh
+++ b/vm/vm/main/cached/Chunk-implem.hh
@@ -17,9 +17,7 @@ void TypeInfoOf<Chunk>::gCollect(GC gc, RichNode from, StableNode& to) const {
 
 void TypeInfoOf<Chunk>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<Chunk>(gc->vm, gc, from.access<Chunk>());
+  to.make<Chunk>(gc->vm, gc, from.access<Chunk>());
 }
 
 void TypeInfoOf<Chunk>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -33,31 +31,31 @@ void TypeInfoOf<Chunk>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Chunk>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<Chunk>::getUnderlying() {
   return _self.access<Chunk>().getUnderlying();
 }
 
 inline
-bool  TypedRichNode<Chunk>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Chunk>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Chunk>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Chunk>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Chunk>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Chunk>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Chunk>::isChunk(VM vm) {
+bool  TypedRichNode<Chunk>::isChunk(mozart::VM vm) {
   return _self.access<Chunk>().isChunk(vm);
 }
 
 inline
-void  TypedRichNode<Chunk>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Chunk>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Chunk>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Chunk>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Chunk>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Chunk>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/ChunkLike-interf.hh b/vm/vm/main/cached/ChunkLike-interf.hh
index 4a35b6b74..daeae8abe 100644
--- a/vm/vm/main/cached/ChunkLike-interf.hh
+++ b/vm/vm/main/cached/ChunkLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ChunkLike(UnstableNode& self) : _self(self) {}
   ChunkLike(StableNode& self) : _self(self) {}
 
-  bool isChunk(VM vm) {
+  bool isChunk(mozart::VM vm) {
     if (_self.is<Chunk>()) {
       return _self.as<Chunk>().isChunk(vm);
     } else if (_self.is<Object>()) {
diff --git a/vm/vm/main/cached/CodeArea-implem-decl-after.hh b/vm/vm/main/cached/CodeArea-implem-decl-after.hh
index 21003cb6c..aa9c96cf6 100644
--- a/vm/vm/main/cached/CodeArea-implem-decl-after.hh
+++ b/vm/vm/main/cached/CodeArea-implem-decl-after.hh
@@ -51,32 +51,32 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  bool isCodeAreaProvider(VM vm);
+  bool isCodeAreaProvider(mozart::VM vm);
 
   inline
-  void getCodeAreaInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Ks);
+  void getCodeAreaInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getCodeAreaDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getCodeAreaDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void setUUID(VM vm, const struct mozart::UUID & uuid);
+  void setUUID(mozart::VM vm, const mozart::UUID & uuid);
 };
diff --git a/vm/vm/main/cached/CodeArea-implem-decl.hh b/vm/vm/main/cached/CodeArea-implem-decl.hh
index a2ec4250d..22815fbed 100644
--- a/vm/vm/main/cached/CodeArea-implem-decl.hh
+++ b/vm/vm/main/cached/CodeArea-implem-decl.hh
@@ -3,5 +3,5 @@ class CodeArea;
 template <>
 class Storage<CodeArea> {
 public:
-  typedef ImplWithArray<CodeArea, class mozart::StableNode> Type;
+  typedef ImplWithArray<CodeArea, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/CodeArea-implem.hh b/vm/vm/main/cached/CodeArea-implem.hh
index bbe5d81ed..090c1d8a7 100644
--- a/vm/vm/main/cached/CodeArea-implem.hh
+++ b/vm/vm/main/cached/CodeArea-implem.hh
@@ -39,11 +39,11 @@ size_t TypedRichNode<CodeArea>::getArraySize() {
   return _self.access<CodeArea>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<CodeArea>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<CodeArea>::getElementsArray() {
   return _self.access<CodeArea>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<CodeArea>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<CodeArea>::getElements(size_t i) {
   return _self.access<CodeArea>().getElements(i);
 }
 
@@ -53,36 +53,36 @@ size_t  TypedRichNode<CodeArea>::getArraySizeImpl() {
 }
 
 inline
-bool  TypedRichNode<CodeArea>::isCodeAreaProvider(VM vm) {
+bool  TypedRichNode<CodeArea>::isCodeAreaProvider(mozart::VM vm) {
   return _self.access<CodeArea>().isCodeAreaProvider(vm);
 }
 
 inline
-void  TypedRichNode<CodeArea>::getCodeAreaInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<CodeArea>::getCodeAreaInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Ks) {
   _self.access<CodeArea>().getCodeAreaInfo(vm, arity, start, Xcount, Ks);
 }
 
 inline
-void  TypedRichNode<CodeArea>::getCodeAreaDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<CodeArea>::getCodeAreaDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<CodeArea>().getCodeAreaDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<CodeArea>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<CodeArea>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<CodeArea>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<CodeArea>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<CodeArea>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<CodeArea>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<CodeArea>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<CodeArea>::globalize(mozart::VM vm) {
   return _self.access<CodeArea>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<CodeArea>::setUUID(VM vm, const struct mozart::UUID & uuid) {
+void  TypedRichNode<CodeArea>::setUUID(mozart::VM vm, const mozart::UUID & uuid) {
   _self.access<CodeArea>().setUUID(_self, vm, uuid);
 }
diff --git a/vm/vm/main/cached/CodeAreaProvider-interf.hh b/vm/vm/main/cached/CodeAreaProvider-interf.hh
index b37b30ffc..80eef0fbd 100644
--- a/vm/vm/main/cached/CodeAreaProvider-interf.hh
+++ b/vm/vm/main/cached/CodeAreaProvider-interf.hh
@@ -4,7 +4,7 @@ public:
   CodeAreaProvider(UnstableNode& self) : _self(self) {}
   CodeAreaProvider(StableNode& self) : _self(self) {}
 
-  bool isCodeAreaProvider(VM vm) {
+  bool isCodeAreaProvider(mozart::VM vm) {
     if (_self.is<CodeArea>()) {
       return _self.as<CodeArea>().isCodeAreaProvider(vm);
     } else if (_self.isTransient()) {
@@ -15,7 +15,7 @@ public:
     }
   }
 
-  void getCodeAreaInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Ks) {
+  void getCodeAreaInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Ks) {
     if (_self.is<CodeArea>()) {
       return _self.as<CodeArea>().getCodeAreaInfo(vm, arity, start, Xcount, Ks);
     } else if (_self.isTransient()) {
@@ -26,7 +26,7 @@ public:
     }
   }
 
-  void getCodeAreaDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+  void getCodeAreaDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
     if (_self.is<CodeArea>()) {
       return _self.as<CodeArea>().getCodeAreaDebugInfo(vm, printName, debugData);
     } else if (_self.isTransient()) {
diff --git a/vm/vm/main/cached/Comparable-interf.hh b/vm/vm/main/cached/Comparable-interf.hh
index ce9900b92..e879840e6 100644
--- a/vm/vm/main/cached/Comparable-interf.hh
+++ b/vm/vm/main/cached/Comparable-interf.hh
@@ -4,7 +4,7 @@ public:
   Comparable(UnstableNode& self) : _self(self) {}
   Comparable(StableNode& self) : _self(self) {}
 
-  int compare(VM vm, class mozart::RichNode right) {
+  int compare(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().compare(vm, right);
     } else if (_self.is<BigInt>()) {
diff --git a/vm/vm/main/cached/Cons-implem-decl-after.hh b/vm/vm/main/cached/Cons-implem-decl-after.hh
index a0509c35d..d808eda65 100644
--- a/vm/vm/main/cached/Cons-implem-decl-after.hh
+++ b/vm/vm/main/cached/Cons-implem-decl-after.hh
@@ -45,59 +45,59 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  class mozart::StableNode * getHead();
+  mozart::StableNode * getHead();
 
   inline
-  class mozart::StableNode * getTail();
+  mozart::StableNode * getTail();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  bool hasListRepr(VM vm, int depth);
+  bool hasListRepr(mozart::VM vm, int depth);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/Cons-implem.hh b/vm/vm/main/cached/Cons-implem.hh
index 6eaf7bf15..e331edd33 100644
--- a/vm/vm/main/cached/Cons-implem.hh
+++ b/vm/vm/main/cached/Cons-implem.hh
@@ -31,96 +31,96 @@ void TypeInfoOf<Cons>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-bool  TypedRichNode<Cons>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Cons>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Cons>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Cons>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Cons>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Cons>().lookupFeature(vm, feature, value);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Cons>::getHead() {
+mozart::StableNode *  TypedRichNode<Cons>::getHead() {
   return _self.access<Cons>().getHead();
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Cons>::getTail() {
+mozart::StableNode *  TypedRichNode<Cons>::getTail() {
   return _self.access<Cons>().getTail();
 }
 
 inline
-StaticArray<class mozart::StableNode>  TypedRichNode<Cons>::getElementsArray() {
+StaticArray<mozart::StableNode>  TypedRichNode<Cons>::getElementsArray() {
   return _self.access<Cons>().getElementsArray();
 }
 
 inline
-bool  TypedRichNode<Cons>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Cons>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Cons>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Cons>::isRecord(VM vm) {
+bool  TypedRichNode<Cons>::isRecord(mozart::VM vm) {
   return _self.access<Cons>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Cons>::isTuple(VM vm) {
+bool  TypedRichNode<Cons>::isTuple(mozart::VM vm) {
   return _self.access<Cons>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::label(mozart::VM vm) {
   return _self.access<Cons>().label(vm);
 }
 
 inline
-size_t  TypedRichNode<Cons>::width(VM vm) {
+size_t  TypedRichNode<Cons>::width(mozart::VM vm) {
   return _self.access<Cons>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::arityList(mozart::VM vm) {
   return _self.access<Cons>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::clone(mozart::VM vm) {
   return _self.access<Cons>().clone(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Cons>::waitOr(mozart::VM vm) {
   return _self.access<Cons>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Cons>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Cons>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Cons>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Cons>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Cons>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Cons>().testTuple(vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Cons>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Cons>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Cons>().testLabel(vm, label);
 }
 
 inline
-void  TypedRichNode<Cons>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Cons>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Cons>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-bool  TypedRichNode<Cons>::hasListRepr(VM vm, int depth) {
+bool  TypedRichNode<Cons>::hasListRepr(mozart::VM vm, int depth) {
   return _self.access<Cons>().hasListRepr(vm, depth);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Cons>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Cons>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Cons>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/DataflowVariable-interf.hh b/vm/vm/main/cached/DataflowVariable-interf.hh
index 2f57cd7d1..1cf5935e1 100644
--- a/vm/vm/main/cached/DataflowVariable-interf.hh
+++ b/vm/vm/main/cached/DataflowVariable-interf.hh
@@ -4,7 +4,7 @@ public:
   DataflowVariable(UnstableNode& self) : _self(self) {}
   DataflowVariable(StableNode& self) : _self(self) {}
 
-  void addToSuspendList(VM vm, class mozart::RichNode variable) {
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().addToSuspendList(vm, variable);
     } else if (_self.is<Variable>()) {
@@ -22,7 +22,7 @@ public:
     }
   }
 
-  bool isNeeded(VM vm) {
+  bool isNeeded(mozart::VM vm) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().isNeeded(vm);
     } else if (_self.is<Variable>()) {
@@ -40,7 +40,7 @@ public:
     }
   }
 
-  void markNeeded(VM vm) {
+  void markNeeded(mozart::VM vm) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().markNeeded(vm);
     } else if (_self.is<Variable>()) {
@@ -58,7 +58,7 @@ public:
     }
   }
 
-  void bind(VM vm, class mozart::RichNode src) {
+  void bind(mozart::VM vm, mozart::RichNode src) {
     if (_self.is<OptVar>()) {
       return _self.as<OptVar>().bind(vm, src);
     } else if (_self.is<Variable>()) {
diff --git a/vm/vm/main/cached/Dictionary-implem-decl-after.hh b/vm/vm/main/cached/Dictionary-implem-decl-after.hh
index 7755836e0..9a7a60e0f 100644
--- a/vm/vm/main/cached/Dictionary-implem-decl-after.hh
+++ b/vm/vm/main/cached/Dictionary-implem-decl-after.hh
@@ -42,65 +42,65 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  bool isDictionary(VM vm);
+  bool isDictionary(mozart::VM vm);
 
   inline
-  bool dictIsEmpty(VM vm);
+  bool dictIsEmpty(mozart::VM vm);
 
   inline
-  bool dictMember(VM vm, class mozart::RichNode feature);
+  bool dictMember(mozart::VM vm, mozart::RichNode feature);
 
   inline
-  class mozart::UnstableNode dictGet(VM vm, class mozart::RichNode feature);
+  mozart::UnstableNode dictGet(mozart::VM vm, mozart::RichNode feature);
 
   inline
-  class mozart::UnstableNode dictCondGet(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue);
+  mozart::UnstableNode dictCondGet(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue);
 
   inline
-  void dictPut(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dictPut(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dictExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dictExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dictCondExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue, class mozart::RichNode newValue);
+  mozart::UnstableNode dictCondExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue, mozart::RichNode newValue);
 
   inline
-  void dictRemove(VM vm, class mozart::RichNode feature);
+  void dictRemove(mozart::VM vm, mozart::RichNode feature);
 
   inline
-  void dictRemoveAll(VM vm);
+  void dictRemoveAll(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictKeys(VM vm);
+  mozart::UnstableNode dictKeys(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictEntries(VM vm);
+  mozart::UnstableNode dictEntries(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictItems(VM vm);
+  mozart::UnstableNode dictItems(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode dictClone(VM vm);
+  mozart::UnstableNode dictClone(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::NodeDictionary & getDict();
+  mozart::NodeDictionary & getDict();
 };
diff --git a/vm/vm/main/cached/Dictionary-implem.hh b/vm/vm/main/cached/Dictionary-implem.hh
index 05d4513b9..5641b7c8f 100644
--- a/vm/vm/main/cached/Dictionary-implem.hh
+++ b/vm/vm/main/cached/Dictionary-implem.hh
@@ -34,106 +34,106 @@ void TypeInfoOf<Dictionary>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-class mozart::Space *  TypedRichNode<Dictionary>::home() {
+mozart::Space *  TypedRichNode<Dictionary>::home() {
   return _self.access<Dictionary>().home();
 }
 
 inline
-bool  TypedRichNode<Dictionary>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Dictionary>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Dictionary>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Dictionary>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Dictionary>().lookupFeature(vm, feature, value);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+void  TypedRichNode<Dictionary>::dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   _self.access<Dictionary>().dotAssign(vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   return _self.access<Dictionary>().dotExchange(_self, vm, feature, newValue);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::isDictionary(VM vm) {
+bool  TypedRichNode<Dictionary>::isDictionary(mozart::VM vm) {
   return _self.access<Dictionary>().isDictionary(vm);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::dictIsEmpty(VM vm) {
+bool  TypedRichNode<Dictionary>::dictIsEmpty(mozart::VM vm) {
   return _self.access<Dictionary>().dictIsEmpty(vm);
 }
 
 inline
-bool  TypedRichNode<Dictionary>::dictMember(VM vm, class mozart::RichNode feature) {
+bool  TypedRichNode<Dictionary>::dictMember(mozart::VM vm, mozart::RichNode feature) {
   return _self.access<Dictionary>().dictMember(vm, feature);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictGet(VM vm, class mozart::RichNode feature) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictGet(mozart::VM vm, mozart::RichNode feature) {
   return _self.access<Dictionary>().dictGet(_self, vm, feature);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondGet(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondGet(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue) {
   return _self.access<Dictionary>().dictCondGet(vm, feature, defaultValue);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dictPut(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+void  TypedRichNode<Dictionary>::dictPut(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   _self.access<Dictionary>().dictPut(vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
   return _self.access<Dictionary>().dictExchange(_self, vm, feature, newValue);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictCondExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue, mozart::RichNode newValue) {
   return _self.access<Dictionary>().dictCondExchange(vm, feature, defaultValue, newValue);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dictRemove(VM vm, class mozart::RichNode feature) {
+void  TypedRichNode<Dictionary>::dictRemove(mozart::VM vm, mozart::RichNode feature) {
   _self.access<Dictionary>().dictRemove(vm, feature);
 }
 
 inline
-void  TypedRichNode<Dictionary>::dictRemoveAll(VM vm) {
+void  TypedRichNode<Dictionary>::dictRemoveAll(mozart::VM vm) {
   _self.access<Dictionary>().dictRemoveAll(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictKeys(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictKeys(mozart::VM vm) {
   return _self.access<Dictionary>().dictKeys(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictEntries(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictEntries(mozart::VM vm) {
   return _self.access<Dictionary>().dictEntries(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictItems(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictItems(mozart::VM vm) {
   return _self.access<Dictionary>().dictItems(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Dictionary>::dictClone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Dictionary>::dictClone(mozart::VM vm) {
   return _self.access<Dictionary>().dictClone(vm);
 }
 
 inline
-void  TypedRichNode<Dictionary>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Dictionary>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Dictionary>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::NodeDictionary &  TypedRichNode<Dictionary>::getDict() {
+mozart::NodeDictionary &  TypedRichNode<Dictionary>::getDict() {
   return _self.access<Dictionary>().getDict();
 }
diff --git a/vm/vm/main/cached/DictionaryLike-interf.hh b/vm/vm/main/cached/DictionaryLike-interf.hh
index 06fc94d0f..f5538659b 100644
--- a/vm/vm/main/cached/DictionaryLike-interf.hh
+++ b/vm/vm/main/cached/DictionaryLike-interf.hh
@@ -4,7 +4,7 @@ public:
   DictionaryLike(UnstableNode& self) : _self(self) {}
   DictionaryLike(StableNode& self) : _self(self) {}
 
-  bool isDictionary(VM vm) {
+  bool isDictionary(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().isDictionary(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  bool dictIsEmpty(VM vm) {
+  bool dictIsEmpty(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictIsEmpty(vm);
     } else if (_self.isTransient()) {
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  bool dictMember(VM vm, class mozart::RichNode feature) {
+  bool dictMember(mozart::VM vm, mozart::RichNode feature) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictMember(vm, feature);
     } else if (_self.isTransient()) {
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictGet(VM vm, class mozart::RichNode feature) {
+  mozart::UnstableNode dictGet(mozart::VM vm, mozart::RichNode feature) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictGet(vm, feature);
     } else if (_self.isTransient()) {
@@ -60,7 +60,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictGet", "dictGet", feature, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -68,7 +68,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictCondGet(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue) {
+  mozart::UnstableNode dictCondGet(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictCondGet(vm, feature, defaultValue);
     } else if (_self.isTransient()) {
@@ -76,7 +76,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictCondGet", "dictCondGet", feature, defaultValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -84,7 +84,7 @@ public:
     }
   }
 
-  void dictPut(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  void dictPut(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictPut(vm, feature, newValue);
     } else if (_self.isTransient()) {
@@ -99,7 +99,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  mozart::UnstableNode dictExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictExchange(vm, feature, newValue);
     } else if (_self.isTransient()) {
@@ -107,7 +107,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictExchange", "dictExchange", feature, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -115,7 +115,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictCondExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode defaultValue, class mozart::RichNode newValue) {
+  mozart::UnstableNode dictCondExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode defaultValue, mozart::RichNode newValue) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictCondExchange(vm, feature, defaultValue, newValue);
     } else if (_self.isTransient()) {
@@ -123,7 +123,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictCondExchange", "dictCondExchange", feature, defaultValue, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -131,7 +131,7 @@ public:
     }
   }
 
-  void dictRemove(VM vm, class mozart::RichNode feature) {
+  void dictRemove(mozart::VM vm, mozart::RichNode feature) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictRemove(vm, feature);
     } else if (_self.isTransient()) {
@@ -146,7 +146,7 @@ public:
     }
   }
 
-  void dictRemoveAll(VM vm) {
+  void dictRemoveAll(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictRemoveAll(vm);
     } else if (_self.isTransient()) {
@@ -161,7 +161,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictKeys(VM vm) {
+  mozart::UnstableNode dictKeys(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictKeys(vm);
     } else if (_self.isTransient()) {
@@ -169,7 +169,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictKeys", "dictKeys", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -177,7 +177,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictEntries(VM vm) {
+  mozart::UnstableNode dictEntries(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictEntries(vm);
     } else if (_self.isTransient()) {
@@ -185,7 +185,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictEntries", "dictEntries", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -193,7 +193,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictItems(VM vm) {
+  mozart::UnstableNode dictItems(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictItems(vm);
     } else if (_self.isTransient()) {
@@ -201,7 +201,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictItems", "dictItems", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -209,7 +209,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dictClone(VM vm) {
+  mozart::UnstableNode dictClone(mozart::VM vm) {
     if (_self.is<Dictionary>()) {
       return _self.as<Dictionary>().dictClone(vm);
     } else if (_self.isTransient()) {
@@ -217,7 +217,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DictionaryLike::dictClone", "dictClone", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/DotAssignable-interf.hh b/vm/vm/main/cached/DotAssignable-interf.hh
index 66ae750a6..c5a41bc7c 100644
--- a/vm/vm/main/cached/DotAssignable-interf.hh
+++ b/vm/vm/main/cached/DotAssignable-interf.hh
@@ -4,7 +4,7 @@ public:
   DotAssignable(UnstableNode& self) : _self(self) {}
   DotAssignable(StableNode& self) : _self(self) {}
 
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Array>()) {
       return _self.as<Array>().dotAssign(vm, feature, newValue);
     } else if (_self.is<Dictionary>()) {
@@ -21,7 +21,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue) {
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue) {
     if (_self.is<Array>()) {
       return _self.as<Array>().dotExchange(vm, feature, newValue);
     } else if (_self.is<Dictionary>()) {
@@ -31,7 +31,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::DotAssignable::dotExchange", "dotExchange", feature, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/FailedSpace-implem-decl-after.hh b/vm/vm/main/cached/FailedSpace-implem-decl-after.hh
index 135b1978f..1be98382a 100644
--- a/vm/vm/main/cached/FailedSpace-implem-decl-after.hh
+++ b/vm/vm/main/cached/FailedSpace-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isSpace(VM vm);
+  bool isSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askSpace(VM vm);
+  mozart::UnstableNode askSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askVerboseSpace(VM vm);
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode mergeSpace(VM vm);
+  mozart::UnstableNode mergeSpace(mozart::VM vm);
 
   inline
-  void commitSpace(VM vm, class mozart::RichNode value);
+  void commitSpace(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode cloneSpace(VM vm);
+  mozart::UnstableNode cloneSpace(mozart::VM vm);
 
   inline
-  void killSpace(VM vm);
+  void killSpace(mozart::VM vm);
 };
diff --git a/vm/vm/main/cached/FailedSpace-implem-decl.hh b/vm/vm/main/cached/FailedSpace-implem-decl.hh
index 331ad0949..ca053fd9e 100644
--- a/vm/vm/main/cached/FailedSpace-implem-decl.hh
+++ b/vm/vm/main/cached/FailedSpace-implem-decl.hh
@@ -3,5 +3,5 @@ class FailedSpace;
 template <>
 class Storage<FailedSpace> {
 public:
-  typedef struct mozart::unit_t Type;
+  typedef mozart::unit_t Type;
 };
diff --git a/vm/vm/main/cached/FailedSpace-implem.hh b/vm/vm/main/cached/FailedSpace-implem.hh
index 0c00900b9..588ef9457 100644
--- a/vm/vm/main/cached/FailedSpace-implem.hh
+++ b/vm/vm/main/cached/FailedSpace-implem.hh
@@ -20,36 +20,36 @@ void TypeInfoOf<FailedSpace>::sClone(SC sc, RichNode from, UnstableNode& to) con
 }
 
 inline
-bool  TypedRichNode<FailedSpace>::isSpace(VM vm) {
+bool  TypedRichNode<FailedSpace>::isSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().isSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::askSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::askSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().askSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::askVerboseSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::askVerboseSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().askVerboseSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::mergeSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::mergeSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().mergeSpace(vm);
 }
 
 inline
-void  TypedRichNode<FailedSpace>::commitSpace(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<FailedSpace>::commitSpace(mozart::VM vm, mozart::RichNode value) {
   _self.access<FailedSpace>().commitSpace(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<FailedSpace>::cloneSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<FailedSpace>::cloneSpace(mozart::VM vm) {
   return _self.access<FailedSpace>().cloneSpace(vm);
 }
 
 inline
-void  TypedRichNode<FailedSpace>::killSpace(VM vm) {
+void  TypedRichNode<FailedSpace>::killSpace(mozart::VM vm) {
   _self.access<FailedSpace>().killSpace(vm);
 }
diff --git a/vm/vm/main/cached/FailedValue-implem-decl-after.hh b/vm/vm/main/cached/FailedValue-implem-decl-after.hh
index 0653a8f01..6e3ab4033 100644
--- a/vm/vm/main/cached/FailedValue-implem-decl-after.hh
+++ b/vm/vm/main/cached/FailedValue-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 
   inline
-  void raiseUnderlying(VM vm);
+  void raiseUnderlying(mozart::VM vm);
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/FailedValue-implem-decl.hh b/vm/vm/main/cached/FailedValue-implem-decl.hh
index 0b8df9f7a..2117d2b9f 100644
--- a/vm/vm/main/cached/FailedValue-implem-decl.hh
+++ b/vm/vm/main/cached/FailedValue-implem-decl.hh
@@ -3,5 +3,5 @@ class FailedValue;
 template <>
 class Storage<FailedValue> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/vm/main/cached/FailedValue-implem.hh b/vm/vm/main/cached/FailedValue-implem.hh
index f23db8fd5..e71befc2f 100644
--- a/vm/vm/main/cached/FailedValue-implem.hh
+++ b/vm/vm/main/cached/FailedValue-implem.hh
@@ -12,9 +12,7 @@ void TypeInfoOf<FailedValue>::gCollect(GC gc, RichNode from, StableNode& to) con
 
 void TypeInfoOf<FailedValue>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<FailedValue>(gc->vm, gc, from.access<FailedValue>());
+  to.make<FailedValue>(gc->vm, gc, from.access<FailedValue>());
 }
 
 void TypeInfoOf<FailedValue>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -28,36 +26,36 @@ void TypeInfoOf<FailedValue>::sClone(SC sc, RichNode from, UnstableNode& to) con
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<FailedValue>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<FailedValue>::getUnderlying() {
   return _self.access<FailedValue>().getUnderlying();
 }
 
 inline
-void  TypedRichNode<FailedValue>::raiseUnderlying(VM vm) {
+void  TypedRichNode<FailedValue>::raiseUnderlying(mozart::VM vm) {
   _self.access<FailedValue>().raiseUnderlying(vm);
 }
 
 inline
-void  TypedRichNode<FailedValue>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<FailedValue>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<FailedValue>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<FailedValue>::isNeeded(VM vm) {
+bool  TypedRichNode<FailedValue>::isNeeded(mozart::VM vm) {
   return _self.access<FailedValue>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<FailedValue>::markNeeded(VM vm) {
+void  TypedRichNode<FailedValue>::markNeeded(mozart::VM vm) {
   _self.access<FailedValue>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<FailedValue>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<FailedValue>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<FailedValue>().bind(vm, src);
 }
 
 inline
-void  TypedRichNode<FailedValue>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<FailedValue>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<FailedValue>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Float-implem-decl-after.hh b/vm/vm/main/cached/Float-implem-decl-after.hh
index 9a618418b..442e4bc86 100644
--- a/vm/vm/main/cached/Float-implem-decl-after.hh
+++ b/vm/vm/main/cached/Float-implem-decl-after.hh
@@ -45,131 +45,131 @@ public:
   double value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isNumber(VM vm);
+  bool isNumber(mozart::VM vm);
 
   inline
-  bool isInt(VM vm);
+  bool isInt(mozart::VM vm);
 
   inline
-  bool isFloat(VM vm);
+  bool isFloat(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode opposite(VM vm);
+  mozart::UnstableNode opposite(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode add(VM vm, nativeint right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint right);
 
   inline
-  class mozart::UnstableNode addValue(VM vm, double b);
+  mozart::UnstableNode addValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode subtractValue(VM vm, double b);
+  mozart::UnstableNode subtractValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode multiplyValue(VM vm, double b);
+  mozart::UnstableNode multiplyValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode divide(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode divide(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode divideValue(VM vm, double b);
+  mozart::UnstableNode divideValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode fmod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode fmod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode fmodValue(VM vm, double b);
+  mozart::UnstableNode fmodValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode pow(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode pow(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode powValue(VM vm, double b);
+  mozart::UnstableNode powValue(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode abs(VM vm);
+  mozart::UnstableNode abs(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode acos(VM vm);
+  mozart::UnstableNode acos(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode acosh(VM vm);
+  mozart::UnstableNode acosh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode asin(VM vm);
+  mozart::UnstableNode asin(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode asinh(VM vm);
+  mozart::UnstableNode asinh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode atan(VM vm);
+  mozart::UnstableNode atan(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode atanh(VM vm);
+  mozart::UnstableNode atanh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode atan2(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode atan2(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode atan2Value(VM vm, double b);
+  mozart::UnstableNode atan2Value(mozart::VM vm, double b);
 
   inline
-  class mozart::UnstableNode ceil(VM vm);
+  mozart::UnstableNode ceil(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode cos(VM vm);
+  mozart::UnstableNode cos(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode cosh(VM vm);
+  mozart::UnstableNode cosh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode exp(VM vm);
+  mozart::UnstableNode exp(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode floor(VM vm);
+  mozart::UnstableNode floor(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode log(VM vm);
+  mozart::UnstableNode log(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode round(VM vm);
+  mozart::UnstableNode round(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode sin(VM vm);
+  mozart::UnstableNode sin(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode sinh(VM vm);
+  mozart::UnstableNode sinh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode sqrt(VM vm);
+  mozart::UnstableNode sqrt(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode tan(VM vm);
+  mozart::UnstableNode tan(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode tanh(VM vm);
+  mozart::UnstableNode tanh(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Float-implem.hh b/vm/vm/main/cached/Float-implem.hh
index 80b8de832..70319222b 100644
--- a/vm/vm/main/cached/Float-implem.hh
+++ b/vm/vm/main/cached/Float-implem.hh
@@ -31,216 +31,216 @@ double  TypedRichNode<Float>::value() {
 }
 
 inline
-bool  TypedRichNode<Float>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Float>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Float>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Float>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<Float>::isNumber(VM vm) {
+bool  TypedRichNode<Float>::isNumber(mozart::VM vm) {
   return _self.access<Float>().isNumber(vm);
 }
 
 inline
-bool  TypedRichNode<Float>::isInt(VM vm) {
+bool  TypedRichNode<Float>::isInt(mozart::VM vm) {
   return _self.access<Float>().isInt(vm);
 }
 
 inline
-bool  TypedRichNode<Float>::isFloat(VM vm) {
+bool  TypedRichNode<Float>::isFloat(mozart::VM vm) {
   return _self.access<Float>().isFloat(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::opposite(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::opposite(mozart::VM vm) {
   return _self.access<Float>().opposite(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::add(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::add(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().add(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::add(VM vm, nativeint right) {
+mozart::UnstableNode  TypedRichNode<Float>::add(mozart::VM vm, mozart::nativeint right) {
   return _self.access<Float>().add(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::addValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::addValue(mozart::VM vm, double b) {
   return _self.access<Float>().addValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::subtract(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::subtract(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().subtract(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::subtractValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::subtractValue(mozart::VM vm, double b) {
   return _self.access<Float>().subtractValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::multiply(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::multiply(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().multiply(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::multiplyValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::multiplyValue(mozart::VM vm, double b) {
   return _self.access<Float>().multiplyValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::divide(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::divide(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().divide(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::divideValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::divideValue(mozart::VM vm, double b) {
   return _self.access<Float>().divideValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::fmod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::fmod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().fmod(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::fmodValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::fmodValue(mozart::VM vm, double b) {
   return _self.access<Float>().fmodValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::div(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::div(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().div(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::mod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::mod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().mod(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::pow(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::pow(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().pow(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::powValue(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::powValue(mozart::VM vm, double b) {
   return _self.access<Float>().powValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::abs(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::abs(mozart::VM vm) {
   return _self.access<Float>().abs(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::acos(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::acos(mozart::VM vm) {
   return _self.access<Float>().acos(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::acosh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::acosh(mozart::VM vm) {
   return _self.access<Float>().acosh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::asin(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::asin(mozart::VM vm) {
   return _self.access<Float>().asin(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::asinh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::asinh(mozart::VM vm) {
   return _self.access<Float>().asinh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atan(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::atan(mozart::VM vm) {
   return _self.access<Float>().atan(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atanh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::atanh(mozart::VM vm) {
   return _self.access<Float>().atanh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atan2(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<Float>::atan2(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Float>().atan2(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::atan2Value(VM vm, double b) {
+mozart::UnstableNode  TypedRichNode<Float>::atan2Value(mozart::VM vm, double b) {
   return _self.access<Float>().atan2Value(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::ceil(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::ceil(mozart::VM vm) {
   return _self.access<Float>().ceil(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::cos(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::cos(mozart::VM vm) {
   return _self.access<Float>().cos(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::cosh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::cosh(mozart::VM vm) {
   return _self.access<Float>().cosh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::exp(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::exp(mozart::VM vm) {
   return _self.access<Float>().exp(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::floor(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::floor(mozart::VM vm) {
   return _self.access<Float>().floor(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::log(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::log(mozart::VM vm) {
   return _self.access<Float>().log(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::round(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::round(mozart::VM vm) {
   return _self.access<Float>().round(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::sin(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::sin(mozart::VM vm) {
   return _self.access<Float>().sin(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::sinh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::sinh(mozart::VM vm) {
   return _self.access<Float>().sinh(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::sqrt(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::sqrt(mozart::VM vm) {
   return _self.access<Float>().sqrt(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::tan(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::tan(mozart::VM vm) {
   return _self.access<Float>().tan(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Float>::tanh(VM vm) {
+mozart::UnstableNode  TypedRichNode<Float>::tanh(mozart::VM vm) {
   return _self.access<Float>().tanh(vm);
 }
 
 inline
-void  TypedRichNode<Float>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Float>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Float>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/FloatLike-interf.hh b/vm/vm/main/cached/FloatLike-interf.hh
index 5ed019bcb..378ed579a 100644
--- a/vm/vm/main/cached/FloatLike-interf.hh
+++ b/vm/vm/main/cached/FloatLike-interf.hh
@@ -4,7 +4,7 @@ public:
   FloatLike(UnstableNode& self) : _self(self) {}
   FloatLike(StableNode& self) : _self(self) {}
 
-  class mozart::UnstableNode divide(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode divide(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().divide(vm, right);
     } else if (_self.isTransient()) {
@@ -12,7 +12,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::divide", "divide", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode pow(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode pow(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().pow(vm, right);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::pow", "pow", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode fmod(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode fmod(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().fmod(vm, right);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::fmod", "fmod", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode acos(VM vm) {
+  mozart::UnstableNode acos(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().acos(vm);
     } else if (_self.isTransient()) {
@@ -60,7 +60,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::acos", "acos", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -68,7 +68,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode acosh(VM vm) {
+  mozart::UnstableNode acosh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().acosh(vm);
     } else if (_self.isTransient()) {
@@ -76,7 +76,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::acosh", "acosh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -84,7 +84,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode asin(VM vm) {
+  mozart::UnstableNode asin(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().asin(vm);
     } else if (_self.isTransient()) {
@@ -92,7 +92,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::asin", "asin", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -100,7 +100,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode asinh(VM vm) {
+  mozart::UnstableNode asinh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().asinh(vm);
     } else if (_self.isTransient()) {
@@ -108,7 +108,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::asinh", "asinh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -116,7 +116,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode atan(VM vm) {
+  mozart::UnstableNode atan(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().atan(vm);
     } else if (_self.isTransient()) {
@@ -124,7 +124,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::atan", "atan", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -132,7 +132,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode atanh(VM vm) {
+  mozart::UnstableNode atanh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().atanh(vm);
     } else if (_self.isTransient()) {
@@ -140,7 +140,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::atanh", "atanh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -148,7 +148,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode atan2(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode atan2(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<Float>()) {
       return _self.as<Float>().atan2(vm, right);
     } else if (_self.isTransient()) {
@@ -156,7 +156,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::atan2", "atan2", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -164,7 +164,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode ceil(VM vm) {
+  mozart::UnstableNode ceil(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().ceil(vm);
     } else if (_self.isTransient()) {
@@ -172,7 +172,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::ceil", "ceil", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -180,7 +180,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode cos(VM vm) {
+  mozart::UnstableNode cos(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().cos(vm);
     } else if (_self.isTransient()) {
@@ -188,7 +188,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::cos", "cos", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -196,7 +196,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode cosh(VM vm) {
+  mozart::UnstableNode cosh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().cosh(vm);
     } else if (_self.isTransient()) {
@@ -204,7 +204,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::cosh", "cosh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -212,7 +212,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode exp(VM vm) {
+  mozart::UnstableNode exp(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().exp(vm);
     } else if (_self.isTransient()) {
@@ -220,7 +220,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::exp", "exp", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -228,7 +228,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode floor(VM vm) {
+  mozart::UnstableNode floor(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().floor(vm);
     } else if (_self.isTransient()) {
@@ -236,7 +236,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::floor", "floor", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -244,7 +244,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode log(VM vm) {
+  mozart::UnstableNode log(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().log(vm);
     } else if (_self.isTransient()) {
@@ -252,7 +252,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::log", "log", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -260,7 +260,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode round(VM vm) {
+  mozart::UnstableNode round(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().round(vm);
     } else if (_self.isTransient()) {
@@ -268,7 +268,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::round", "round", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -276,7 +276,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sin(VM vm) {
+  mozart::UnstableNode sin(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().sin(vm);
     } else if (_self.isTransient()) {
@@ -284,7 +284,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::sin", "sin", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -292,7 +292,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sinh(VM vm) {
+  mozart::UnstableNode sinh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().sinh(vm);
     } else if (_self.isTransient()) {
@@ -300,7 +300,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::sinh", "sinh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -308,7 +308,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sqrt(VM vm) {
+  mozart::UnstableNode sqrt(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().sqrt(vm);
     } else if (_self.isTransient()) {
@@ -316,7 +316,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::sqrt", "sqrt", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -324,7 +324,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode tan(VM vm) {
+  mozart::UnstableNode tan(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().tan(vm);
     } else if (_self.isTransient()) {
@@ -332,7 +332,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::tan", "tan", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -340,7 +340,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode tanh(VM vm) {
+  mozart::UnstableNode tanh(mozart::VM vm) {
     if (_self.is<Float>()) {
       return _self.as<Float>().tanh(vm);
     } else if (_self.isTransient()) {
@@ -348,7 +348,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::FloatLike::tanh", "tanh", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/GRedToStable-implem-decl-after.hh b/vm/vm/main/cached/GRedToStable-implem-decl-after.hh
index 1e6f61480..d770190bd 100644
--- a/vm/vm/main/cached/GRedToStable-implem-decl-after.hh
+++ b/vm/vm/main/cached/GRedToStable-implem-decl-after.hh
@@ -22,5 +22,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * dest();
+  mozart::StableNode * dest();
 };
diff --git a/vm/vm/main/cached/GRedToStable-implem-decl.hh b/vm/vm/main/cached/GRedToStable-implem-decl.hh
index daad688fd..8a239de87 100644
--- a/vm/vm/main/cached/GRedToStable-implem-decl.hh
+++ b/vm/vm/main/cached/GRedToStable-implem-decl.hh
@@ -3,5 +3,5 @@ class GRedToStable;
 template <>
 class Storage<GRedToStable> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/vm/main/cached/GRedToStable-implem.hh b/vm/vm/main/cached/GRedToStable-implem.hh
index 1f13544ad..8991ab6a7 100644
--- a/vm/vm/main/cached/GRedToStable-implem.hh
+++ b/vm/vm/main/cached/GRedToStable-implem.hh
@@ -1,5 +1,5 @@
 
 inline
-class mozart::StableNode *  TypedRichNode<GRedToStable>::dest() {
+mozart::StableNode *  TypedRichNode<GRedToStable>::dest() {
   return _self.access<GRedToStable>().dest();
 }
diff --git a/vm/vm/main/cached/GRedToUnstable-implem-decl-after.hh b/vm/vm/main/cached/GRedToUnstable-implem-decl-after.hh
index f3b6b92f0..12e0cfaec 100644
--- a/vm/vm/main/cached/GRedToUnstable-implem-decl-after.hh
+++ b/vm/vm/main/cached/GRedToUnstable-implem-decl-after.hh
@@ -22,5 +22,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::UnstableNode * dest();
+  mozart::UnstableNode * dest();
 };
diff --git a/vm/vm/main/cached/GRedToUnstable-implem-decl.hh b/vm/vm/main/cached/GRedToUnstable-implem-decl.hh
index 853fbcf76..31dcdde51 100644
--- a/vm/vm/main/cached/GRedToUnstable-implem-decl.hh
+++ b/vm/vm/main/cached/GRedToUnstable-implem-decl.hh
@@ -3,5 +3,5 @@ class GRedToUnstable;
 template <>
 class Storage<GRedToUnstable> {
 public:
-  typedef class mozart::UnstableNode * Type;
+  typedef mozart::UnstableNode * Type;
 };
diff --git a/vm/vm/main/cached/GRedToUnstable-implem.hh b/vm/vm/main/cached/GRedToUnstable-implem.hh
index 25623d55d..f2b8cb91a 100644
--- a/vm/vm/main/cached/GRedToUnstable-implem.hh
+++ b/vm/vm/main/cached/GRedToUnstable-implem.hh
@@ -1,5 +1,5 @@
 
 inline
-class mozart::UnstableNode *  TypedRichNode<GRedToUnstable>::dest() {
+mozart::UnstableNode *  TypedRichNode<GRedToUnstable>::dest() {
   return _self.access<GRedToUnstable>().dest();
 }
diff --git a/vm/vm/main/cached/GlobalName-implem-decl-after.hh b/vm/vm/main/cached/GlobalName-implem-decl-after.hh
index e1af26e47..2a40df500 100644
--- a/vm/vm/main/cached/GlobalName-implem-decl-after.hh
+++ b/vm/vm/main/cached/GlobalName-implem-decl-after.hh
@@ -48,59 +48,59 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  const struct mozart::UUID & getUUID();
+  const mozart::UUID & getUUID();
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/GlobalName-implem.hh b/vm/vm/main/cached/GlobalName-implem.hh
index e4e1a44bc..88bd11044 100644
--- a/vm/vm/main/cached/GlobalName-implem.hh
+++ b/vm/vm/main/cached/GlobalName-implem.hh
@@ -44,96 +44,96 @@ int TypeInfoOf<GlobalName>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) c
 
 
 inline
-class mozart::Space *  TypedRichNode<GlobalName>::home() {
+mozart::Space *  TypedRichNode<GlobalName>::home() {
   return _self.access<GlobalName>().home();
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isLiteral(VM vm) {
+bool  TypedRichNode<GlobalName>::isLiteral(mozart::VM vm) {
   return _self.access<GlobalName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<GlobalName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<GlobalName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<GlobalName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<GlobalName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isRecord(VM vm) {
+bool  TypedRichNode<GlobalName>::isRecord(mozart::VM vm) {
   return _self.access<GlobalName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isTuple(VM vm) {
+bool  TypedRichNode<GlobalName>::isTuple(mozart::VM vm) {
   return _self.access<GlobalName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::label(mozart::VM vm) {
   return _self.access<GlobalName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<GlobalName>::width(VM vm) {
+size_t  TypedRichNode<GlobalName>::width(mozart::VM vm) {
   return _self.access<GlobalName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::arityList(mozart::VM vm) {
   return _self.access<GlobalName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::clone(mozart::VM vm) {
   return _self.access<GlobalName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<GlobalName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<GlobalName>::waitOr(mozart::VM vm) {
   return _self.access<GlobalName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<GlobalName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<GlobalName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<GlobalName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<GlobalName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<GlobalName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<GlobalName>().testLabel(_self, vm, label);
 }
 
 inline
-const struct mozart::UUID &  TypedRichNode<GlobalName>::getUUID() {
+const mozart::UUID &  TypedRichNode<GlobalName>::getUUID() {
   return _self.access<GlobalName>().getUUID();
 }
 
 inline
-int  TypedRichNode<GlobalName>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<GlobalName>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<GlobalName>().compareFeatures(vm, right);
 }
 
 inline
-bool  TypedRichNode<GlobalName>::isName(VM vm) {
+bool  TypedRichNode<GlobalName>::isName(mozart::VM vm) {
   return _self.access<GlobalName>().isName(vm);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<GlobalName>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<GlobalName>::globalize(mozart::VM vm) {
   return _self.access<GlobalName>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<GlobalName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<GlobalName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<GlobalName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Literal-interf.hh b/vm/vm/main/cached/Literal-interf.hh
index f0a885d9d..30f51823c 100644
--- a/vm/vm/main/cached/Literal-interf.hh
+++ b/vm/vm/main/cached/Literal-interf.hh
@@ -4,7 +4,7 @@ public:
   Literal(UnstableNode& self) : _self(self) {}
   Literal(StableNode& self) : _self(self) {}
 
-  bool isLiteral(VM vm) {
+  bool isLiteral(mozart::VM vm) {
     if (_self.is<Atom>()) {
       return _self.as<Atom>().isLiteral(vm);
     } else if (_self.is<OptName>()) {
diff --git a/vm/vm/main/cached/MergedSpace-implem-decl-after.hh b/vm/vm/main/cached/MergedSpace-implem-decl-after.hh
index 3bde0a933..557923f3a 100644
--- a/vm/vm/main/cached/MergedSpace-implem-decl-after.hh
+++ b/vm/vm/main/cached/MergedSpace-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isSpace(VM vm);
+  bool isSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askSpace(VM vm);
+  mozart::UnstableNode askSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askVerboseSpace(VM vm);
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode mergeSpace(VM vm);
+  mozart::UnstableNode mergeSpace(mozart::VM vm);
 
   inline
-  void commitSpace(VM vm, class mozart::RichNode value);
+  void commitSpace(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode cloneSpace(VM vm);
+  mozart::UnstableNode cloneSpace(mozart::VM vm);
 
   inline
-  void killSpace(VM vm);
+  void killSpace(mozart::VM vm);
 };
diff --git a/vm/vm/main/cached/MergedSpace-implem-decl.hh b/vm/vm/main/cached/MergedSpace-implem-decl.hh
index aff5c8efb..03469ff4c 100644
--- a/vm/vm/main/cached/MergedSpace-implem-decl.hh
+++ b/vm/vm/main/cached/MergedSpace-implem-decl.hh
@@ -3,5 +3,5 @@ class MergedSpace;
 template <>
 class Storage<MergedSpace> {
 public:
-  typedef struct mozart::unit_t Type;
+  typedef mozart::unit_t Type;
 };
diff --git a/vm/vm/main/cached/MergedSpace-implem.hh b/vm/vm/main/cached/MergedSpace-implem.hh
index bb4e3744d..4ef9df96d 100644
--- a/vm/vm/main/cached/MergedSpace-implem.hh
+++ b/vm/vm/main/cached/MergedSpace-implem.hh
@@ -20,36 +20,36 @@ void TypeInfoOf<MergedSpace>::sClone(SC sc, RichNode from, UnstableNode& to) con
 }
 
 inline
-bool  TypedRichNode<MergedSpace>::isSpace(VM vm) {
+bool  TypedRichNode<MergedSpace>::isSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().isSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::askSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::askSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().askSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::askVerboseSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::askVerboseSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().askVerboseSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::mergeSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::mergeSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().mergeSpace(vm);
 }
 
 inline
-void  TypedRichNode<MergedSpace>::commitSpace(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<MergedSpace>::commitSpace(mozart::VM vm, mozart::RichNode value) {
   _self.access<MergedSpace>().commitSpace(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<MergedSpace>::cloneSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<MergedSpace>::cloneSpace(mozart::VM vm) {
   return _self.access<MergedSpace>().cloneSpace(vm);
 }
 
 inline
-void  TypedRichNode<MergedSpace>::killSpace(VM vm) {
+void  TypedRichNode<MergedSpace>::killSpace(mozart::VM vm) {
   _self.access<MergedSpace>().killSpace(vm);
 }
diff --git a/vm/vm/main/cached/NameLike-interf.hh b/vm/vm/main/cached/NameLike-interf.hh
index e5c82d4e6..72b138925 100644
--- a/vm/vm/main/cached/NameLike-interf.hh
+++ b/vm/vm/main/cached/NameLike-interf.hh
@@ -4,7 +4,7 @@ public:
   NameLike(UnstableNode& self) : _self(self) {}
   NameLike(StableNode& self) : _self(self) {}
 
-  bool isName(VM vm) {
+  bool isName(mozart::VM vm) {
     if (_self.is<OptName>()) {
       return _self.as<OptName>().isName(vm);
     } else if (_self.is<GlobalName>()) {
diff --git a/vm/vm/main/cached/NamedName-implem-decl-after.hh b/vm/vm/main/cached/NamedName-implem-decl-after.hh
index bd92add5e..2c981f9a8 100644
--- a/vm/vm/main/cached/NamedName-implem-decl-after.hh
+++ b/vm/vm/main/cached/NamedName-implem-decl-after.hh
@@ -51,65 +51,65 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  const struct mozart::UUID & getUUID();
+  const mozart::UUID & getUUID();
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/NamedName-implem.hh b/vm/vm/main/cached/NamedName-implem.hh
index 322a89afa..1fcc1a859 100644
--- a/vm/vm/main/cached/NamedName-implem.hh
+++ b/vm/vm/main/cached/NamedName-implem.hh
@@ -49,106 +49,106 @@ int TypeInfoOf<NamedName>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) co
 
 
 inline
-class mozart::Space *  TypedRichNode<NamedName>::home() {
+mozart::Space *  TypedRichNode<NamedName>::home() {
   return _self.access<NamedName>().home();
 }
 
 inline
-bool  TypedRichNode<NamedName>::isLiteral(VM vm) {
+bool  TypedRichNode<NamedName>::isLiteral(mozart::VM vm) {
   return _self.access<NamedName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<NamedName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<NamedName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<NamedName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<NamedName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<NamedName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<NamedName>::isRecord(VM vm) {
+bool  TypedRichNode<NamedName>::isRecord(mozart::VM vm) {
   return _self.access<NamedName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::isTuple(VM vm) {
+bool  TypedRichNode<NamedName>::isTuple(mozart::VM vm) {
   return _self.access<NamedName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::label(mozart::VM vm) {
   return _self.access<NamedName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<NamedName>::width(VM vm) {
+size_t  TypedRichNode<NamedName>::width(mozart::VM vm) {
   return _self.access<NamedName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::arityList(mozart::VM vm) {
   return _self.access<NamedName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::clone(mozart::VM vm) {
   return _self.access<NamedName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<NamedName>::waitOr(mozart::VM vm) {
   return _self.access<NamedName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<NamedName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<NamedName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<NamedName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<NamedName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<NamedName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<NamedName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<NamedName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<NamedName>().testLabel(_self, vm, label);
 }
 
 inline
-const struct mozart::UUID &  TypedRichNode<NamedName>::getUUID() {
+const mozart::UUID &  TypedRichNode<NamedName>::getUUID() {
   return _self.access<NamedName>().getUUID();
 }
 
 inline
-int  TypedRichNode<NamedName>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<NamedName>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<NamedName>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<NamedName>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<NamedName>::getPrintName(mozart::VM vm) {
   return _self.access<NamedName>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<NamedName>::isName(VM vm) {
+bool  TypedRichNode<NamedName>::isName(mozart::VM vm) {
   return _self.access<NamedName>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<NamedName>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<NamedName>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<NamedName>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<NamedName>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<NamedName>::globalize(mozart::VM vm) {
   return _self.access<NamedName>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<NamedName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<NamedName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<NamedName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Numeric-interf.hh b/vm/vm/main/cached/Numeric-interf.hh
index bc54a5970..7ca56dc3a 100644
--- a/vm/vm/main/cached/Numeric-interf.hh
+++ b/vm/vm/main/cached/Numeric-interf.hh
@@ -4,7 +4,7 @@ public:
   Numeric(UnstableNode& self) : _self(self) {}
   Numeric(StableNode& self) : _self(self) {}
 
-  bool isNumber(VM vm) {
+  bool isNumber(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().isNumber(vm);
     } else if (_self.is<BigInt>()) {
@@ -24,7 +24,7 @@ public:
     }
   }
 
-  bool isInt(VM vm) {
+  bool isInt(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().isInt(vm);
     } else if (_self.is<BigInt>()) {
@@ -44,7 +44,7 @@ public:
     }
   }
 
-  bool isFloat(VM vm) {
+  bool isFloat(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().isFloat(vm);
     } else if (_self.is<BigInt>()) {
@@ -64,7 +64,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode opposite(VM vm) {
+  mozart::UnstableNode opposite(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().opposite(vm);
     } else if (_self.is<BigInt>()) {
@@ -76,7 +76,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::opposite", "opposite", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -84,7 +84,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().add(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -96,7 +96,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::add", "add", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -104,7 +104,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode add(VM vm, nativeint right) {
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().add(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -116,7 +116,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::add", "add", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -124,7 +124,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().subtract(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -136,7 +136,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::subtract", "subtract", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -144,7 +144,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().multiply(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -156,7 +156,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::multiply", "multiply", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -164,7 +164,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().div(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -176,7 +176,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::div", "div", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -184,7 +184,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().mod(vm, right);
     } else if (_self.is<BigInt>()) {
@@ -196,7 +196,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::mod", "mod", right, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -204,7 +204,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode abs(VM vm) {
+  mozart::UnstableNode abs(mozart::VM vm) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().abs(vm);
     } else if (_self.is<BigInt>()) {
@@ -216,7 +216,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::Numeric::abs", "abs", ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/Object-implem-decl-after.hh b/vm/vm/main/cached/Object-implem-decl-after.hh
index 7fa0a65e0..d21398dc1 100644
--- a/vm/vm/main/cached/Object-implem-decl-after.hh
+++ b/vm/vm/main/cached/Object-implem-decl-after.hh
@@ -45,59 +45,59 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::UnstableNode> getElementsArray();
+  StaticArray<mozart::UnstableNode> getElementsArray();
 
   inline
-  class mozart::UnstableNode& getElements(size_t i);
+  mozart::UnstableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getFeaturesRecord();
+  mozart::StableNode * getFeaturesRecord();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isChunk(VM vm);
+  bool isChunk(mozart::VM vm);
 
   inline
-  bool isObject(VM vm);
+  bool isObject(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode getClass(VM vm);
+  mozart::UnstableNode getClass(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode attrGet(VM vm, class mozart::RichNode attribute);
+  mozart::UnstableNode attrGet(mozart::VM vm, mozart::RichNode attribute);
 
   inline
-  void attrPut(VM vm, class mozart::RichNode attribute, class mozart::RichNode value);
+  void attrPut(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode attrExchange(VM vm, class mozart::RichNode attribute, class mozart::RichNode newValue);
+  mozart::UnstableNode attrExchange(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode newValue);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Object-implem-decl.hh b/vm/vm/main/cached/Object-implem-decl.hh
index fb6aa23b2..003b6dded 100644
--- a/vm/vm/main/cached/Object-implem-decl.hh
+++ b/vm/vm/main/cached/Object-implem-decl.hh
@@ -3,5 +3,5 @@ class Object;
 template <>
 class Storage<Object> {
 public:
-  typedef ImplWithArray<Object, class mozart::UnstableNode> Type;
+  typedef ImplWithArray<Object, mozart::UnstableNode> Type;
 };
diff --git a/vm/vm/main/cached/Object-implem.hh b/vm/vm/main/cached/Object-implem.hh
index 9ea9fd70a..b64af5029 100644
--- a/vm/vm/main/cached/Object-implem.hh
+++ b/vm/vm/main/cached/Object-implem.hh
@@ -37,16 +37,16 @@ size_t TypedRichNode<Object>::getArraySize() {
   return _self.access<Object>().getArraySize();
 }
 
-StaticArray<class mozart::UnstableNode> TypedRichNode<Object>::getElementsArray() {
+StaticArray<mozart::UnstableNode> TypedRichNode<Object>::getElementsArray() {
   return _self.access<Object>().getElementsArray();
 }
 
-class mozart::UnstableNode& TypedRichNode<Object>::getElements(size_t i) {
+mozart::UnstableNode& TypedRichNode<Object>::getElements(size_t i) {
   return _self.access<Object>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Object>::home() {
+mozart::Space *  TypedRichNode<Object>::home() {
   return _self.access<Object>().home();
 }
 
@@ -56,76 +56,76 @@ size_t  TypedRichNode<Object>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Object>::getFeaturesRecord() {
+mozart::StableNode *  TypedRichNode<Object>::getFeaturesRecord() {
   return _self.access<Object>().getFeaturesRecord();
 }
 
 inline
-bool  TypedRichNode<Object>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Object>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Object>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Object>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Object>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Object>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Object>::isChunk(VM vm) {
+bool  TypedRichNode<Object>::isChunk(mozart::VM vm) {
   return _self.access<Object>().isChunk(vm);
 }
 
 inline
-bool  TypedRichNode<Object>::isObject(VM vm) {
+bool  TypedRichNode<Object>::isObject(mozart::VM vm) {
   return _self.access<Object>().isObject(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Object>::getClass(VM vm) {
+mozart::UnstableNode  TypedRichNode<Object>::getClass(mozart::VM vm) {
   return _self.access<Object>().getClass(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Object>::attrGet(VM vm, class mozart::RichNode attribute) {
+mozart::UnstableNode  TypedRichNode<Object>::attrGet(mozart::VM vm, mozart::RichNode attribute) {
   return _self.access<Object>().attrGet(_self, vm, attribute);
 }
 
 inline
-void  TypedRichNode<Object>::attrPut(VM vm, class mozart::RichNode attribute, class mozart::RichNode value) {
+void  TypedRichNode<Object>::attrPut(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode value) {
   _self.access<Object>().attrPut(_self, vm, attribute, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Object>::attrExchange(VM vm, class mozart::RichNode attribute, class mozart::RichNode newValue) {
+mozart::UnstableNode  TypedRichNode<Object>::attrExchange(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode newValue) {
   return _self.access<Object>().attrExchange(_self, vm, attribute, newValue);
 }
 
 inline
-bool  TypedRichNode<Object>::isCallable(VM vm) {
+bool  TypedRichNode<Object>::isCallable(mozart::VM vm) {
   return _self.access<Object>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<Object>::isProcedure(VM vm) {
+bool  TypedRichNode<Object>::isProcedure(mozart::VM vm) {
   return _self.access<Object>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<Object>::procedureArity(VM vm) {
+size_t  TypedRichNode<Object>::procedureArity(mozart::VM vm) {
   return _self.access<Object>().procedureArity(_self, vm);
 }
 
 inline
-void  TypedRichNode<Object>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<Object>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<Object>().getCallInfo(_self, vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<Object>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<Object>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<Object>().getDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<Object>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Object>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Object>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ObjectLike-interf.hh b/vm/vm/main/cached/ObjectLike-interf.hh
index c51e26493..974a9ce94 100644
--- a/vm/vm/main/cached/ObjectLike-interf.hh
+++ b/vm/vm/main/cached/ObjectLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ObjectLike(UnstableNode& self) : _self(self) {}
   ObjectLike(StableNode& self) : _self(self) {}
 
-  bool isObject(VM vm) {
+  bool isObject(mozart::VM vm) {
     if (_self.is<Object>()) {
       return _self.as<Object>().isObject(vm);
     } else if (_self.isTransient()) {
@@ -20,7 +20,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode getClass(VM vm) {
+  mozart::UnstableNode getClass(mozart::VM vm) {
     if (_self.is<Object>()) {
       return _self.as<Object>().getClass(vm);
     } else if (_self.isTransient()) {
@@ -28,7 +28,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ObjectLike::getClass", "getClass", ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -36,7 +36,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode attrGet(VM vm, class mozart::RichNode attribute) {
+  mozart::UnstableNode attrGet(mozart::VM vm, mozart::RichNode attribute) {
     if (_self.is<Object>()) {
       return _self.as<Object>().attrGet(vm, attribute);
     } else if (_self.isTransient()) {
@@ -44,7 +44,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ObjectLike::attrGet", "attrGet", attribute, ::mozart::ozcalls::out(_result)))
           return _result;
       }
@@ -52,7 +52,7 @@ public:
     }
   }
 
-  void attrPut(VM vm, class mozart::RichNode attribute, class mozart::RichNode value) {
+  void attrPut(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode value) {
     if (_self.is<Object>()) {
       return _self.as<Object>().attrPut(vm, attribute, value);
     } else if (_self.isTransient()) {
@@ -67,7 +67,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode attrExchange(VM vm, class mozart::RichNode attribute, class mozart::RichNode newValue) {
+  mozart::UnstableNode attrExchange(mozart::VM vm, mozart::RichNode attribute, mozart::RichNode newValue) {
     if (_self.is<Object>()) {
       return _self.as<Object>().attrExchange(vm, attribute, newValue);
     } else if (_self.isTransient()) {
@@ -75,7 +75,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::ObjectLike::attrExchange", "attrExchange", attribute, newValue, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/OptName-implem-decl-after.hh b/vm/vm/main/cached/OptName-implem-decl-after.hh
index 8cf97a211..d569f3ebd 100644
--- a/vm/vm/main/cached/OptName-implem-decl-after.hh
+++ b/vm/vm/main/cached/OptName-implem-decl-after.hh
@@ -45,56 +45,56 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void makeFeature(VM vm);
+  void makeFeature(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/OptName-implem-decl.hh b/vm/vm/main/cached/OptName-implem-decl.hh
index 0ed0d4ab0..2aad0d9f7 100644
--- a/vm/vm/main/cached/OptName-implem-decl.hh
+++ b/vm/vm/main/cached/OptName-implem-decl.hh
@@ -3,5 +3,5 @@ class OptName;
 template <>
 class Storage<OptName> {
 public:
-  typedef struct mozart::SpaceRef Type;
+  typedef mozart::SpaceRef Type;
 };
diff --git a/vm/vm/main/cached/OptName-implem.hh b/vm/vm/main/cached/OptName-implem.hh
index f13f5537c..09f2264ff 100644
--- a/vm/vm/main/cached/OptName-implem.hh
+++ b/vm/vm/main/cached/OptName-implem.hh
@@ -39,91 +39,91 @@ void TypeInfoOf<OptName>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<OptName>::home() {
+mozart::Space *  TypedRichNode<OptName>::home() {
   return _self.access<OptName>().home();
 }
 
 inline
-bool  TypedRichNode<OptName>::isLiteral(VM vm) {
+bool  TypedRichNode<OptName>::isLiteral(mozart::VM vm) {
   return _self.access<OptName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<OptName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<OptName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<OptName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<OptName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<OptName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<OptName>::isRecord(VM vm) {
+bool  TypedRichNode<OptName>::isRecord(mozart::VM vm) {
   return _self.access<OptName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::isTuple(VM vm) {
+bool  TypedRichNode<OptName>::isTuple(mozart::VM vm) {
   return _self.access<OptName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::label(mozart::VM vm) {
   return _self.access<OptName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<OptName>::width(VM vm) {
+size_t  TypedRichNode<OptName>::width(mozart::VM vm) {
   return _self.access<OptName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::arityList(mozart::VM vm) {
   return _self.access<OptName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::clone(mozart::VM vm) {
   return _self.access<OptName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<OptName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<OptName>::waitOr(mozart::VM vm) {
   return _self.access<OptName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<OptName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<OptName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<OptName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<OptName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<OptName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<OptName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<OptName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<OptName>().testLabel(_self, vm, label);
 }
 
 inline
-void  TypedRichNode<OptName>::makeFeature(VM vm) {
+void  TypedRichNode<OptName>::makeFeature(mozart::VM vm) {
   _self.access<OptName>().makeFeature(_self, vm);
 }
 
 inline
-bool  TypedRichNode<OptName>::isName(VM vm) {
+bool  TypedRichNode<OptName>::isName(mozart::VM vm) {
   return _self.access<OptName>().isName(vm);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<OptName>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<OptName>::globalize(mozart::VM vm) {
   return _self.access<OptName>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<OptName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<OptName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<OptName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/OptVar-implem-decl-after.hh b/vm/vm/main/cached/OptVar-implem-decl-after.hh
index 008159bef..736bc8bdf 100644
--- a/vm/vm/main/cached/OptVar-implem-decl-after.hh
+++ b/vm/vm/main/cached/OptVar-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::UnstableNode && src);
+  void bind(mozart::VM vm, mozart::UnstableNode && src);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/OptVar-implem-decl.hh b/vm/vm/main/cached/OptVar-implem-decl.hh
index 8c2b657fd..0317b422f 100644
--- a/vm/vm/main/cached/OptVar-implem-decl.hh
+++ b/vm/vm/main/cached/OptVar-implem-decl.hh
@@ -3,5 +3,5 @@ class OptVar;
 template <>
 class Storage<OptVar> {
 public:
-  typedef struct mozart::SpaceRef Type;
+  typedef mozart::SpaceRef Type;
 };
diff --git a/vm/vm/main/cached/OptVar-implem.hh b/vm/vm/main/cached/OptVar-implem.hh
index 50226a95e..263a43939 100644
--- a/vm/vm/main/cached/OptVar-implem.hh
+++ b/vm/vm/main/cached/OptVar-implem.hh
@@ -34,36 +34,36 @@ void TypeInfoOf<OptVar>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<OptVar>::home() {
+mozart::Space *  TypedRichNode<OptVar>::home() {
   return _self.access<OptVar>().home();
 }
 
 inline
-void  TypedRichNode<OptVar>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<OptVar>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<OptVar>().addToSuspendList(_self, vm, variable);
 }
 
 inline
-bool  TypedRichNode<OptVar>::isNeeded(VM vm) {
+bool  TypedRichNode<OptVar>::isNeeded(mozart::VM vm) {
   return _self.access<OptVar>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<OptVar>::markNeeded(VM vm) {
+void  TypedRichNode<OptVar>::markNeeded(mozart::VM vm) {
   _self.access<OptVar>().markNeeded(_self, vm);
 }
 
 inline
-void  TypedRichNode<OptVar>::bind(VM vm, class mozart::UnstableNode && src) {
+void  TypedRichNode<OptVar>::bind(mozart::VM vm, mozart::UnstableNode && src) {
   _self.access<OptVar>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<OptVar>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<OptVar>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<OptVar>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<OptVar>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<OptVar>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<OptVar>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/PatMatCapture-implem-decl-after.hh b/vm/vm/main/cached/PatMatCapture-implem-decl-after.hh
index 321e88774..79d0613ec 100644
--- a/vm/vm/main/cached/PatMatCapture-implem-decl-after.hh
+++ b/vm/vm/main/cached/PatMatCapture-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<PatMatCapture>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("PatMatCapture", uuid(), (! ::mozart::MemWord::requiresExternalMemory<nativeint>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("PatMatCapture", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::nativeint>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<PatMatCapture>* const instance() {
     return &RawType<PatMatCapture>::rawType;
@@ -41,14 +41,14 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  nativeint index();
+  mozart::nativeint index();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/PatMatCapture-implem-decl.hh b/vm/vm/main/cached/PatMatCapture-implem-decl.hh
index f3090965b..6eae9b615 100644
--- a/vm/vm/main/cached/PatMatCapture-implem-decl.hh
+++ b/vm/vm/main/cached/PatMatCapture-implem-decl.hh
@@ -3,5 +3,5 @@ class PatMatCapture;
 template <>
 class Storage<PatMatCapture> {
 public:
-  typedef nativeint Type;
+  typedef mozart::nativeint Type;
 };
diff --git a/vm/vm/main/cached/PatMatCapture-implem.hh b/vm/vm/main/cached/PatMatCapture-implem.hh
index d42c86d86..a95caf2a6 100644
--- a/vm/vm/main/cached/PatMatCapture-implem.hh
+++ b/vm/vm/main/cached/PatMatCapture-implem.hh
@@ -31,21 +31,21 @@ void TypeInfoOf<PatMatCapture>::sClone(SC sc, RichNode from, UnstableNode& to) c
 }
 
 inline
-nativeint  TypedRichNode<PatMatCapture>::index() {
+mozart::nativeint  TypedRichNode<PatMatCapture>::index() {
   return _self.access<PatMatCapture>().index();
 }
 
 inline
-bool  TypedRichNode<PatMatCapture>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<PatMatCapture>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<PatMatCapture>().equals(vm, right);
 }
 
 inline
-void  TypedRichNode<PatMatCapture>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<PatMatCapture>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<PatMatCapture>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<PatMatCapture>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<PatMatCapture>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<PatMatCapture>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/PatMatConjunction-implem-decl-after.hh b/vm/vm/main/cached/PatMatConjunction-implem-decl-after.hh
index e89baac01..36b79ca31 100644
--- a/vm/vm/main/cached/PatMatConjunction-implem-decl-after.hh
+++ b/vm/vm/main/cached/PatMatConjunction-implem-decl-after.hh
@@ -44,10 +44,10 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
@@ -56,14 +56,14 @@ public:
   size_t getCount();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/PatMatConjunction-implem-decl.hh b/vm/vm/main/cached/PatMatConjunction-implem-decl.hh
index 8fa48dec6..7b85b228f 100644
--- a/vm/vm/main/cached/PatMatConjunction-implem-decl.hh
+++ b/vm/vm/main/cached/PatMatConjunction-implem-decl.hh
@@ -3,5 +3,5 @@ class PatMatConjunction;
 template <>
 class Storage<PatMatConjunction> {
 public:
-  typedef ImplWithArray<PatMatConjunction, class mozart::StableNode> Type;
+  typedef ImplWithArray<PatMatConjunction, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/PatMatConjunction-implem.hh b/vm/vm/main/cached/PatMatConjunction-implem.hh
index 598418b75..74e009a67 100644
--- a/vm/vm/main/cached/PatMatConjunction-implem.hh
+++ b/vm/vm/main/cached/PatMatConjunction-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<PatMatConjunction>::getArraySize() {
   return _self.access<PatMatConjunction>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<PatMatConjunction>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<PatMatConjunction>::getElementsArray() {
   return _self.access<PatMatConjunction>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<PatMatConjunction>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<PatMatConjunction>::getElements(size_t i) {
   return _self.access<PatMatConjunction>().getElements(i);
 }
 
@@ -53,21 +53,21 @@ size_t  TypedRichNode<PatMatConjunction>::getCount() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<PatMatConjunction>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<PatMatConjunction>::getElement(size_t index) {
   return _self.access<PatMatConjunction>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<PatMatConjunction>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<PatMatConjunction>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<PatMatConjunction>().equals(vm, right, stack);
 }
 
 inline
-void  TypedRichNode<PatMatConjunction>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<PatMatConjunction>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<PatMatConjunction>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<PatMatConjunction>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<PatMatConjunction>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<PatMatConjunction>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/PatMatOpenRecord-implem-decl-after.hh b/vm/vm/main/cached/PatMatOpenRecord-implem-decl-after.hh
index 5337cd28b..da7dfed9a 100644
--- a/vm/vm/main/cached/PatMatOpenRecord-implem-decl-after.hh
+++ b/vm/vm/main/cached/PatMatOpenRecord-implem-decl-after.hh
@@ -44,23 +44,23 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  class mozart::StableNode * getArity();
+  mozart::StableNode * getArity();
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/PatMatOpenRecord-implem-decl.hh b/vm/vm/main/cached/PatMatOpenRecord-implem-decl.hh
index c16fdab30..27af0c35f 100644
--- a/vm/vm/main/cached/PatMatOpenRecord-implem-decl.hh
+++ b/vm/vm/main/cached/PatMatOpenRecord-implem-decl.hh
@@ -3,5 +3,5 @@ class PatMatOpenRecord;
 template <>
 class Storage<PatMatOpenRecord> {
 public:
-  typedef ImplWithArray<PatMatOpenRecord, class mozart::StableNode> Type;
+  typedef ImplWithArray<PatMatOpenRecord, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/PatMatOpenRecord-implem.hh b/vm/vm/main/cached/PatMatOpenRecord-implem.hh
index cd155e426..835b802f8 100644
--- a/vm/vm/main/cached/PatMatOpenRecord-implem.hh
+++ b/vm/vm/main/cached/PatMatOpenRecord-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<PatMatOpenRecord>::getArraySize() {
   return _self.access<PatMatOpenRecord>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<PatMatOpenRecord>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<PatMatOpenRecord>::getElementsArray() {
   return _self.access<PatMatOpenRecord>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<PatMatOpenRecord>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<PatMatOpenRecord>::getElements(size_t i) {
   return _self.access<PatMatOpenRecord>().getElements(i);
 }
 
@@ -48,21 +48,21 @@ size_t  TypedRichNode<PatMatOpenRecord>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getElement(size_t index) {
   return _self.access<PatMatOpenRecord>().getElement(index);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getArity() {
+mozart::StableNode *  TypedRichNode<PatMatOpenRecord>::getArity() {
   return _self.access<PatMatOpenRecord>().getArity();
 }
 
 inline
-void  TypedRichNode<PatMatOpenRecord>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<PatMatOpenRecord>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<PatMatOpenRecord>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<PatMatOpenRecord>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<PatMatOpenRecord>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<PatMatOpenRecord>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/Port-implem-decl-after.hh b/vm/vm/main/cached/Port-implem-decl-after.hh
index d277a737f..3fe77f3ae 100644
--- a/vm/vm/main/cached/Port-implem-decl-after.hh
+++ b/vm/vm/main/cached/Port-implem-decl-after.hh
@@ -42,17 +42,17 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool isPort(VM vm);
+  bool isPort(mozart::VM vm);
 
   inline
-  void send(VM vm, class mozart::RichNode value);
+  void send(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode sendReceive(VM vm, class mozart::RichNode value);
+  mozart::UnstableNode sendReceive(mozart::VM vm, mozart::RichNode value);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Port-implem.hh b/vm/vm/main/cached/Port-implem.hh
index 66fededf2..2822dd614 100644
--- a/vm/vm/main/cached/Port-implem.hh
+++ b/vm/vm/main/cached/Port-implem.hh
@@ -34,26 +34,26 @@ void TypeInfoOf<Port>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-class mozart::Space *  TypedRichNode<Port>::home() {
+mozart::Space *  TypedRichNode<Port>::home() {
   return _self.access<Port>().home();
 }
 
 inline
-bool  TypedRichNode<Port>::isPort(VM vm) {
+bool  TypedRichNode<Port>::isPort(mozart::VM vm) {
   return _self.access<Port>().isPort(vm);
 }
 
 inline
-void  TypedRichNode<Port>::send(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<Port>::send(mozart::VM vm, mozart::RichNode value) {
   _self.access<Port>().send(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Port>::sendReceive(VM vm, class mozart::RichNode value) {
+mozart::UnstableNode  TypedRichNode<Port>::sendReceive(mozart::VM vm, mozart::RichNode value) {
   return _self.access<Port>().sendReceive(vm, value);
 }
 
 inline
-void  TypedRichNode<Port>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Port>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Port>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/PortLike-interf.hh b/vm/vm/main/cached/PortLike-interf.hh
index b001e3d26..bc8313344 100644
--- a/vm/vm/main/cached/PortLike-interf.hh
+++ b/vm/vm/main/cached/PortLike-interf.hh
@@ -4,7 +4,7 @@ public:
   PortLike(UnstableNode& self) : _self(self) {}
   PortLike(StableNode& self) : _self(self) {}
 
-  bool isPort(VM vm) {
+  bool isPort(mozart::VM vm) {
     if (_self.is<Port>()) {
       return _self.as<Port>().isPort(vm);
     } else if (_self.is<VMPort>()) {
@@ -22,7 +22,7 @@ public:
     }
   }
 
-  void send(VM vm, class mozart::RichNode value) {
+  void send(mozart::VM vm, mozart::RichNode value) {
     if (_self.is<Port>()) {
       return _self.as<Port>().send(vm, value);
     } else if (_self.is<VMPort>()) {
@@ -39,7 +39,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode sendReceive(VM vm, class mozart::RichNode value) {
+  mozart::UnstableNode sendReceive(mozart::VM vm, mozart::RichNode value) {
     if (_self.is<Port>()) {
       return _self.as<Port>().sendReceive(vm, value);
     } else if (_self.is<VMPort>()) {
@@ -49,7 +49,7 @@ public:
       throw std::exception(); // not reachable
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        class mozart::UnstableNode _result;
+        mozart::UnstableNode _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::PortLike::sendReceive", "sendReceive", value, ::mozart::ozcalls::out(_result)))
           return _result;
       }
diff --git a/vm/vm/main/cached/PotentialFeature-interf.hh b/vm/vm/main/cached/PotentialFeature-interf.hh
index 206771623..3d8bf1f64 100644
--- a/vm/vm/main/cached/PotentialFeature-interf.hh
+++ b/vm/vm/main/cached/PotentialFeature-interf.hh
@@ -4,7 +4,7 @@ public:
   PotentialFeature(UnstableNode& self) : _self(self) {}
   PotentialFeature(StableNode& self) : _self(self) {}
 
-  void makeFeature(VM vm) {
+  void makeFeature(mozart::VM vm) {
     if (_self.is<OptName>()) {
       return _self.as<OptName>().makeFeature(vm);
     } else if (_self.isTransient()) {
diff --git a/vm/vm/main/cached/ReadOnly-implem-decl-after.hh b/vm/vm/main/cached/ReadOnly-implem-decl-after.hh
index 8f23c5529..a4af6999f 100644
--- a/vm/vm/main/cached/ReadOnly-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReadOnly-implem-decl-after.hh
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 
   inline
-  void wakeUp(VM vm);
+  void wakeUp(mozart::VM vm);
 
   inline
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space);
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space);
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/ReadOnly-implem-decl.hh b/vm/vm/main/cached/ReadOnly-implem-decl.hh
index b654dcbb4..33d9f29de 100644
--- a/vm/vm/main/cached/ReadOnly-implem-decl.hh
+++ b/vm/vm/main/cached/ReadOnly-implem-decl.hh
@@ -3,5 +3,5 @@ class ReadOnly;
 template <>
 class Storage<ReadOnly> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/vm/main/cached/ReadOnly-implem.hh b/vm/vm/main/cached/ReadOnly-implem.hh
index ab24fdc54..ea2bd3858 100644
--- a/vm/vm/main/cached/ReadOnly-implem.hh
+++ b/vm/vm/main/cached/ReadOnly-implem.hh
@@ -12,9 +12,7 @@ void TypeInfoOf<ReadOnly>::gCollect(GC gc, RichNode from, StableNode& to) const
 
 void TypeInfoOf<ReadOnly>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<ReadOnly>(gc->vm, gc, from.access<ReadOnly>());
+  to.make<ReadOnly>(gc->vm, gc, from.access<ReadOnly>());
 }
 
 void TypeInfoOf<ReadOnly>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -28,41 +26,41 @@ void TypeInfoOf<ReadOnly>::sClone(SC sc, RichNode from, UnstableNode& to) const
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<ReadOnly>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<ReadOnly>::getUnderlying() {
   return _self.access<ReadOnly>().getUnderlying();
 }
 
 inline
-void  TypedRichNode<ReadOnly>::wakeUp(VM vm) {
+void  TypedRichNode<ReadOnly>::wakeUp(mozart::VM vm) {
   _self.access<ReadOnly>().wakeUp(_self, vm);
 }
 
 inline
-bool  TypedRichNode<ReadOnly>::shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+bool  TypedRichNode<ReadOnly>::shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
   return _self.access<ReadOnly>().shouldWakeUpUnderSpace(vm, space);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<ReadOnly>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<ReadOnly>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<ReadOnly>::isNeeded(VM vm) {
+bool  TypedRichNode<ReadOnly>::isNeeded(mozart::VM vm) {
   return _self.access<ReadOnly>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::markNeeded(VM vm) {
+void  TypedRichNode<ReadOnly>::markNeeded(mozart::VM vm) {
   _self.access<ReadOnly>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReadOnly>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReadOnly>().bind(vm, src);
 }
 
 inline
-void  TypedRichNode<ReadOnly>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReadOnly>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReadOnly>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ReadOnlyVariable-implem-decl-after.hh b/vm/vm/main/cached/ReadOnlyVariable-implem-decl-after.hh
index 3dba028a5..4d228f087 100644
--- a/vm/vm/main/cached/ReadOnlyVariable-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReadOnlyVariable-implem-decl-after.hh
@@ -38,23 +38,23 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void bindReadOnly(VM vm, class mozart::RichNode src);
+  void bindReadOnly(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/ReadOnlyVariable-implem.hh b/vm/vm/main/cached/ReadOnlyVariable-implem.hh
index 72f5c8661..26d5f8243 100644
--- a/vm/vm/main/cached/ReadOnlyVariable-implem.hh
+++ b/vm/vm/main/cached/ReadOnlyVariable-implem.hh
@@ -26,36 +26,36 @@ void TypeInfoOf<ReadOnlyVariable>::sClone(SC sc, RichNode from, UnstableNode& to
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReadOnlyVariable>::home() {
+mozart::Space *  TypedRichNode<ReadOnlyVariable>::home() {
   return _self.access<ReadOnlyVariable>().home();
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<ReadOnlyVariable>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<ReadOnlyVariable>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<ReadOnlyVariable>::isNeeded(VM vm) {
+bool  TypedRichNode<ReadOnlyVariable>::isNeeded(mozart::VM vm) {
   return _self.access<ReadOnlyVariable>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::markNeeded(VM vm) {
+void  TypedRichNode<ReadOnlyVariable>::markNeeded(mozart::VM vm) {
   _self.access<ReadOnlyVariable>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReadOnlyVariable>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReadOnlyVariable>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::bindReadOnly(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReadOnlyVariable>::bindReadOnly(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReadOnlyVariable>().bindReadOnly(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<ReadOnlyVariable>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReadOnlyVariable>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReadOnlyVariable>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Record-implem-decl-after.hh b/vm/vm/main/cached/Record-implem-decl-after.hh
index ed2dcb8d3..01cf0a381 100644
--- a/vm/vm/main/cached/Record-implem-decl-after.hh
+++ b/vm/vm/main/cached/Record-implem-decl-after.hh
@@ -48,10 +48,10 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
@@ -60,53 +60,53 @@ public:
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  class mozart::StableNode * getArity();
+  mozart::StableNode * getArity();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/Record-implem-decl.hh b/vm/vm/main/cached/Record-implem-decl.hh
index 65117e3ae..2718b2de7 100644
--- a/vm/vm/main/cached/Record-implem-decl.hh
+++ b/vm/vm/main/cached/Record-implem-decl.hh
@@ -3,5 +3,5 @@ class Record;
 template <>
 class Storage<Record> {
 public:
-  typedef ImplWithArray<Record, class mozart::StableNode> Type;
+  typedef ImplWithArray<Record, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/Record-implem.hh b/vm/vm/main/cached/Record-implem.hh
index 0c9ea6f2c..3b7085b1c 100644
--- a/vm/vm/main/cached/Record-implem.hh
+++ b/vm/vm/main/cached/Record-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Record>::getArraySize() {
   return _self.access<Record>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Record>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Record>::getElementsArray() {
   return _self.access<Record>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Record>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Record>::getElements(size_t i) {
   return _self.access<Record>().getElements(i);
 }
 
@@ -53,86 +53,86 @@ size_t  TypedRichNode<Record>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Record>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Record>::getElement(size_t index) {
   return _self.access<Record>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Record>::isRecord(VM vm) {
+bool  TypedRichNode<Record>::isRecord(mozart::VM vm) {
   return _self.access<Record>().isRecord(vm);
 }
 
 inline
-size_t  TypedRichNode<Record>::width(VM vm) {
+size_t  TypedRichNode<Record>::width(mozart::VM vm) {
   return _self.access<Record>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::arityList(mozart::VM vm) {
   return _self.access<Record>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::waitOr(mozart::VM vm) {
   return _self.access<Record>().waitOr(vm);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Record>::getArity() {
+mozart::StableNode *  TypedRichNode<Record>::getArity() {
   return _self.access<Record>().getArity();
 }
 
 inline
-bool  TypedRichNode<Record>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Record>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Record>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Record>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Record>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Record>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Record>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Record>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Record>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Record>::isTuple(VM vm) {
+bool  TypedRichNode<Record>::isTuple(mozart::VM vm) {
   return _self.access<Record>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::label(mozart::VM vm) {
   return _self.access<Record>().label(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Record>::clone(mozart::VM vm) {
   return _self.access<Record>().clone(vm);
 }
 
 inline
-bool  TypedRichNode<Record>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Record>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Record>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Record>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Record>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Record>().testTuple(vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Record>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Record>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Record>().testLabel(vm, label);
 }
 
 inline
-void  TypedRichNode<Record>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Record>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Record>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Record>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Record>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Record>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/RecordLike-interf.hh b/vm/vm/main/cached/RecordLike-interf.hh
index 68d4313a9..7ea645c25 100644
--- a/vm/vm/main/cached/RecordLike-interf.hh
+++ b/vm/vm/main/cached/RecordLike-interf.hh
@@ -4,7 +4,7 @@ public:
   RecordLike(UnstableNode& self) : _self(self) {}
   RecordLike(StableNode& self) : _self(self) {}
 
-  bool isRecord(VM vm) {
+  bool isRecord(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().isRecord(vm);
     } else if (_self.is<Record>()) {
@@ -29,7 +29,7 @@ public:
     }
   }
 
-  bool isTuple(VM vm) {
+  bool isTuple(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().isTuple(vm);
     } else if (_self.is<Record>()) {
@@ -54,7 +54,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode label(VM vm) {
+  mozart::UnstableNode label(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().label(vm);
     } else if (_self.is<Record>()) {
@@ -79,7 +79,7 @@ public:
     }
   }
 
-  size_t width(VM vm) {
+  size_t width(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().width(vm);
     } else if (_self.is<Record>()) {
@@ -104,7 +104,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode arityList(VM vm) {
+  mozart::UnstableNode arityList(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().arityList(vm);
     } else if (_self.is<Record>()) {
@@ -129,7 +129,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode clone(VM vm) {
+  mozart::UnstableNode clone(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().clone(vm);
     } else if (_self.is<Record>()) {
@@ -154,7 +154,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode waitOr(VM vm) {
+  mozart::UnstableNode waitOr(mozart::VM vm) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().waitOr(vm);
     } else if (_self.is<Record>()) {
@@ -179,7 +179,7 @@ public:
     }
   }
 
-  bool testRecord(VM vm, class mozart::RichNode arity) {
+  bool testRecord(mozart::VM vm, mozart::RichNode arity) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().testRecord(vm, arity);
     } else if (_self.is<Record>()) {
@@ -204,7 +204,7 @@ public:
     }
   }
 
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width) {
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().testTuple(vm, label, width);
     } else if (_self.is<Record>()) {
@@ -229,7 +229,7 @@ public:
     }
   }
 
-  bool testLabel(VM vm, class mozart::RichNode label) {
+  bool testLabel(mozart::VM vm, mozart::RichNode label) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().testLabel(vm, label);
     } else if (_self.is<Record>()) {
diff --git a/vm/vm/main/cached/Reference-implem-decl-after.hh b/vm/vm/main/cached/Reference-implem-decl-after.hh
index 4afce2e5f..f0d962547 100644
--- a/vm/vm/main/cached/Reference-implem-decl-after.hh
+++ b/vm/vm/main/cached/Reference-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<Reference>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("Reference", uuid(), (! ::mozart::MemWord::requiresExternalMemory<class mozart::StableNode *>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("Reference", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::StableNode *>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<Reference>* const instance() {
     return &RawType<Reference>::rawType;
@@ -34,5 +34,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * dest();
+  mozart::StableNode * dest();
 };
diff --git a/vm/vm/main/cached/Reference-implem-decl.hh b/vm/vm/main/cached/Reference-implem-decl.hh
index 65450d9e6..88e3946b5 100644
--- a/vm/vm/main/cached/Reference-implem-decl.hh
+++ b/vm/vm/main/cached/Reference-implem-decl.hh
@@ -3,5 +3,5 @@ class Reference;
 template <>
 class Storage<Reference> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/vm/main/cached/Reference-implem.hh b/vm/vm/main/cached/Reference-implem.hh
index aee78981d..c75725374 100644
--- a/vm/vm/main/cached/Reference-implem.hh
+++ b/vm/vm/main/cached/Reference-implem.hh
@@ -6,9 +6,7 @@ void TypeInfoOf<Reference>::gCollect(GC gc, RichNode from, StableNode& to) const
 
 void TypeInfoOf<Reference>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<Reference>(gc->vm, gc, from.access<Reference>());
+  to.make<Reference>(gc->vm, gc, from.access<Reference>());
 }
 
 void TypeInfoOf<Reference>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -18,12 +16,10 @@ void TypeInfoOf<Reference>::sClone(SC sc, RichNode from, StableNode& to) const {
 
 void TypeInfoOf<Reference>::sClone(SC sc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (sc->vm) StableNode;
-to.make<Reference>(sc->vm, stable);
-stable->make<Reference>(sc->vm, sc, from.access<Reference>());
+  to.make<Reference>(sc->vm, sc, from.access<Reference>());
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Reference>::dest() {
+mozart::StableNode *  TypedRichNode<Reference>::dest() {
   return _self.access<Reference>().dest();
 }
diff --git a/vm/vm/main/cached/ReflectiveEntity-implem-decl-after.hh b/vm/vm/main/cached/ReflectiveEntity-implem-decl-after.hh
index 6277b9d03..716cf6862 100644
--- a/vm/vm/main/cached/ReflectiveEntity-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReflectiveEntity-implem-decl-after.hh
@@ -43,8 +43,8 @@ public:
 
   template <typename Label, typename ... Args> 
   inline
-  bool reflectiveCall(VM vm, const char * identity, Label && label, Args &&... args);
+  bool reflectiveCall(mozart::VM vm, const char * identity, Label && label, Args &&... args);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/ReflectiveEntity-implem.hh b/vm/vm/main/cached/ReflectiveEntity-implem.hh
index a83b2dc04..4ea812666 100644
--- a/vm/vm/main/cached/ReflectiveEntity-implem.hh
+++ b/vm/vm/main/cached/ReflectiveEntity-implem.hh
@@ -27,11 +27,11 @@ void TypeInfoOf<ReflectiveEntity>::sClone(SC sc, RichNode from, UnstableNode& to
 
 template <typename Label, typename ... Args> 
 inline
-bool  TypedRichNode<ReflectiveEntity>::reflectiveCall(VM vm, const char * identity, Label && label, Args &&... args) {
+bool  TypedRichNode<ReflectiveEntity>::reflectiveCall(mozart::VM vm, const char * identity, Label && label, Args &&... args) {
   return _self.access<ReflectiveEntity>().reflectiveCall<Label, Args... >(vm, identity, std::forward<Label>(label), std::forward<Args>(args)...);
 }
 
 inline
-void  TypedRichNode<ReflectiveEntity>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReflectiveEntity>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReflectiveEntity>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ReflectiveVariable-implem-decl-after.hh b/vm/vm/main/cached/ReflectiveVariable-implem-decl-after.hh
index 5ba3a8d10..aa3eae9ff 100644
--- a/vm/vm/main/cached/ReflectiveVariable-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReflectiveVariable-implem-decl-after.hh
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void reflectiveBind(VM vm, class mozart::RichNode src);
+  void reflectiveBind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void bindReadOnly(VM vm, class mozart::RichNode src);
+  void bindReadOnly(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/ReflectiveVariable-implem.hh b/vm/vm/main/cached/ReflectiveVariable-implem.hh
index 1a71b7671..69f7ab847 100644
--- a/vm/vm/main/cached/ReflectiveVariable-implem.hh
+++ b/vm/vm/main/cached/ReflectiveVariable-implem.hh
@@ -26,41 +26,41 @@ void TypeInfoOf<ReflectiveVariable>::sClone(SC sc, RichNode from, UnstableNode&
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReflectiveVariable>::home() {
+mozart::Space *  TypedRichNode<ReflectiveVariable>::home() {
   return _self.access<ReflectiveVariable>().home();
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<ReflectiveVariable>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<ReflectiveVariable>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<ReflectiveVariable>::isNeeded(VM vm) {
+bool  TypedRichNode<ReflectiveVariable>::isNeeded(mozart::VM vm) {
   return _self.access<ReflectiveVariable>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::markNeeded(VM vm) {
+void  TypedRichNode<ReflectiveVariable>::markNeeded(mozart::VM vm) {
   _self.access<ReflectiveVariable>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReflectiveVariable>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReflectiveVariable>().bind(vm, src);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::reflectiveBind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReflectiveVariable>::reflectiveBind(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReflectiveVariable>().reflectiveBind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::bindReadOnly(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<ReflectiveVariable>::bindReadOnly(mozart::VM vm, mozart::RichNode src) {
   _self.access<ReflectiveVariable>().bindReadOnly(vm, src);
 }
 
 inline
-void  TypedRichNode<ReflectiveVariable>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<ReflectiveVariable>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<ReflectiveVariable>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ReifiedGNode-implem-decl-after.hh b/vm/vm/main/cached/ReifiedGNode-implem-decl-after.hh
index 49e77794e..890d91154 100644
--- a/vm/vm/main/cached/ReifiedGNode-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReifiedGNode-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<ReifiedGNode>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("ReifiedGNode", uuid(), (! ::mozart::MemWord::requiresExternalMemory<class mozart::GlobalNode *>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("ReifiedGNode", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::GlobalNode *>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<ReifiedGNode>* const instance() {
     return &RawType<ReifiedGNode>::rawType;
@@ -38,8 +38,8 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::GlobalNode * value();
+  mozart::GlobalNode * value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 };
diff --git a/vm/vm/main/cached/ReifiedGNode-implem-decl.hh b/vm/vm/main/cached/ReifiedGNode-implem-decl.hh
index 249d3d035..09de5a7dd 100644
--- a/vm/vm/main/cached/ReifiedGNode-implem-decl.hh
+++ b/vm/vm/main/cached/ReifiedGNode-implem-decl.hh
@@ -3,5 +3,5 @@ class ReifiedGNode;
 template <>
 class Storage<ReifiedGNode> {
 public:
-  typedef class mozart::GlobalNode * Type;
+  typedef mozart::GlobalNode * Type;
 };
diff --git a/vm/vm/main/cached/ReifiedGNode-implem.hh b/vm/vm/main/cached/ReifiedGNode-implem.hh
index 66a7fe63c..65f19bc24 100644
--- a/vm/vm/main/cached/ReifiedGNode-implem.hh
+++ b/vm/vm/main/cached/ReifiedGNode-implem.hh
@@ -20,11 +20,11 @@ void TypeInfoOf<ReifiedGNode>::sClone(SC sc, RichNode from, UnstableNode& to) co
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<ReifiedGNode>::value() {
+mozart::GlobalNode *  TypedRichNode<ReifiedGNode>::value() {
   return _self.access<ReifiedGNode>().value();
 }
 
 inline
-bool  TypedRichNode<ReifiedGNode>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<ReifiedGNode>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ReifiedGNode>().equals(vm, right);
 }
diff --git a/vm/vm/main/cached/ReifiedSpace-implem-decl-after.hh b/vm/vm/main/cached/ReifiedSpace-implem-decl-after.hh
index abac9cdd4..98791fd58 100644
--- a/vm/vm/main/cached/ReifiedSpace-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReifiedSpace-implem-decl-after.hh
@@ -38,29 +38,29 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  class mozart::Space * getSpace();
+  mozart::Space * getSpace();
 
   inline
-  bool isSpace(VM vm);
+  bool isSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askSpace(VM vm);
+  mozart::UnstableNode askSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode askVerboseSpace(VM vm);
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode mergeSpace(VM vm);
+  mozart::UnstableNode mergeSpace(mozart::VM vm);
 
   inline
-  void commitSpace(VM vm, class mozart::RichNode value);
+  void commitSpace(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode cloneSpace(VM vm);
+  mozart::UnstableNode cloneSpace(mozart::VM vm);
 
   inline
-  void killSpace(VM vm);
+  void killSpace(mozart::VM vm);
 };
diff --git a/vm/vm/main/cached/ReifiedSpace-implem-decl.hh b/vm/vm/main/cached/ReifiedSpace-implem-decl.hh
index d53a51ab9..2752ce98d 100644
--- a/vm/vm/main/cached/ReifiedSpace-implem-decl.hh
+++ b/vm/vm/main/cached/ReifiedSpace-implem-decl.hh
@@ -3,5 +3,5 @@ class ReifiedSpace;
 template <>
 class Storage<ReifiedSpace> {
 public:
-  typedef struct mozart::SpaceRef Type;
+  typedef mozart::SpaceRef Type;
 };
diff --git a/vm/vm/main/cached/ReifiedSpace-implem.hh b/vm/vm/main/cached/ReifiedSpace-implem.hh
index 52bf14d5c..51b0ba870 100644
--- a/vm/vm/main/cached/ReifiedSpace-implem.hh
+++ b/vm/vm/main/cached/ReifiedSpace-implem.hh
@@ -28,46 +28,46 @@ void TypeInfoOf<ReifiedSpace>::sClone(SC sc, RichNode from, UnstableNode& to) co
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReifiedSpace>::home() {
+mozart::Space *  TypedRichNode<ReifiedSpace>::home() {
   return _self.access<ReifiedSpace>().home();
 }
 
 inline
-class mozart::Space *  TypedRichNode<ReifiedSpace>::getSpace() {
+mozart::Space *  TypedRichNode<ReifiedSpace>::getSpace() {
   return _self.access<ReifiedSpace>().getSpace();
 }
 
 inline
-bool  TypedRichNode<ReifiedSpace>::isSpace(VM vm) {
+bool  TypedRichNode<ReifiedSpace>::isSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().isSpace(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().askSpace(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askVerboseSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::askVerboseSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().askVerboseSpace(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::mergeSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::mergeSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().mergeSpace(_self, vm);
 }
 
 inline
-void  TypedRichNode<ReifiedSpace>::commitSpace(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<ReifiedSpace>::commitSpace(mozart::VM vm, mozart::RichNode value) {
   _self.access<ReifiedSpace>().commitSpace(_self, vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<ReifiedSpace>::cloneSpace(VM vm) {
+mozart::UnstableNode  TypedRichNode<ReifiedSpace>::cloneSpace(mozart::VM vm) {
   return _self.access<ReifiedSpace>().cloneSpace(_self, vm);
 }
 
 inline
-void  TypedRichNode<ReifiedSpace>::killSpace(VM vm) {
+void  TypedRichNode<ReifiedSpace>::killSpace(mozart::VM vm) {
   _self.access<ReifiedSpace>().killSpace(_self, vm);
 }
diff --git a/vm/vm/main/cached/ReifiedThread-implem-decl-after.hh b/vm/vm/main/cached/ReifiedThread-implem-decl-after.hh
index e82bec556..8d3bf88b0 100644
--- a/vm/vm/main/cached/ReifiedThread-implem-decl-after.hh
+++ b/vm/vm/main/cached/ReifiedThread-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<ReifiedThread>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("ReifiedThread", uuid(), (! ::mozart::MemWord::requiresExternalMemory<class mozart::Runnable *>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("ReifiedThread", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::Runnable *>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<ReifiedThread>* const instance() {
     return &RawType<ReifiedThread>::rawType;
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::Runnable * value();
+  mozart::Runnable * value();
 
   inline
-  void wakeUp(VM vm);
+  void wakeUp(mozart::VM vm);
 
   inline
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space);
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space);
 
   inline
-  bool isThread(VM vm);
+  bool isThread(mozart::VM vm);
 
   inline
-  enum mozart::ThreadPriority getThreadPriority(VM vm);
+  mozart::ThreadPriority getThreadPriority(mozart::VM vm);
 
   inline
-  void setThreadPriority(VM vm, enum mozart::ThreadPriority priority);
+  void setThreadPriority(mozart::VM vm, mozart::ThreadPriority priority);
 
   inline
-  void injectException(VM vm, class mozart::RichNode exception);
+  void injectException(mozart::VM vm, mozart::RichNode exception);
 };
diff --git a/vm/vm/main/cached/ReifiedThread-implem-decl.hh b/vm/vm/main/cached/ReifiedThread-implem-decl.hh
index a49eaa931..5c7e4c039 100644
--- a/vm/vm/main/cached/ReifiedThread-implem-decl.hh
+++ b/vm/vm/main/cached/ReifiedThread-implem-decl.hh
@@ -3,5 +3,5 @@ class ReifiedThread;
 template <>
 class Storage<ReifiedThread> {
 public:
-  typedef class mozart::Runnable * Type;
+  typedef mozart::Runnable * Type;
 };
diff --git a/vm/vm/main/cached/ReifiedThread-implem.hh b/vm/vm/main/cached/ReifiedThread-implem.hh
index 6f212a4c5..64324d3c4 100644
--- a/vm/vm/main/cached/ReifiedThread-implem.hh
+++ b/vm/vm/main/cached/ReifiedThread-implem.hh
@@ -6,9 +6,7 @@ void TypeInfoOf<ReifiedThread>::gCollect(GC gc, RichNode from, StableNode& to) c
 
 void TypeInfoOf<ReifiedThread>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<ReifiedThread>(gc->vm, gc, from.access<ReifiedThread>());
+  to.make<ReifiedThread>(gc->vm, gc, from.access<ReifiedThread>());
 }
 
 void TypeInfoOf<ReifiedThread>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -18,47 +16,45 @@ void TypeInfoOf<ReifiedThread>::sClone(SC sc, RichNode from, StableNode& to) con
 
 void TypeInfoOf<ReifiedThread>::sClone(SC sc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (sc->vm) StableNode;
-to.make<Reference>(sc->vm, stable);
-stable->make<ReifiedThread>(sc->vm, sc, from.access<ReifiedThread>());
+  to.make<ReifiedThread>(sc->vm, sc, from.access<ReifiedThread>());
 }
 
 inline
-bool  TypedRichNode<ReifiedThread>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<ReifiedThread>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<ReifiedThread>().equals(vm, right);
 }
 
 inline
-class mozart::Runnable *  TypedRichNode<ReifiedThread>::value() {
+mozart::Runnable *  TypedRichNode<ReifiedThread>::value() {
   return _self.access<ReifiedThread>().value();
 }
 
 inline
-void  TypedRichNode<ReifiedThread>::wakeUp(VM vm) {
+void  TypedRichNode<ReifiedThread>::wakeUp(mozart::VM vm) {
   _self.access<ReifiedThread>().wakeUp(vm);
 }
 
 inline
-bool  TypedRichNode<ReifiedThread>::shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+bool  TypedRichNode<ReifiedThread>::shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
   return _self.access<ReifiedThread>().shouldWakeUpUnderSpace(vm, space);
 }
 
 inline
-bool  TypedRichNode<ReifiedThread>::isThread(VM vm) {
+bool  TypedRichNode<ReifiedThread>::isThread(mozart::VM vm) {
   return _self.access<ReifiedThread>().isThread(vm);
 }
 
 inline
-enum mozart::ThreadPriority  TypedRichNode<ReifiedThread>::getThreadPriority(VM vm) {
+mozart::ThreadPriority  TypedRichNode<ReifiedThread>::getThreadPriority(mozart::VM vm) {
   return _self.access<ReifiedThread>().getThreadPriority(vm);
 }
 
 inline
-void  TypedRichNode<ReifiedThread>::setThreadPriority(VM vm, enum mozart::ThreadPriority priority) {
+void  TypedRichNode<ReifiedThread>::setThreadPriority(mozart::VM vm, mozart::ThreadPriority priority) {
   _self.access<ReifiedThread>().setThreadPriority(vm, priority);
 }
 
 inline
-void  TypedRichNode<ReifiedThread>::injectException(VM vm, class mozart::RichNode exception) {
+void  TypedRichNode<ReifiedThread>::injectException(mozart::VM vm, mozart::RichNode exception) {
   _self.access<ReifiedThread>().injectException(vm, exception);
 }
diff --git a/vm/vm/main/cached/Serialized-implem-decl-after.hh b/vm/vm/main/cached/Serialized-implem-decl-after.hh
index 909beb2f5..4f1de9da3 100644
--- a/vm/vm/main/cached/Serialized-implem-decl-after.hh
+++ b/vm/vm/main/cached/Serialized-implem-decl-after.hh
@@ -34,5 +34,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  nativeint n();
+  mozart::nativeint n();
 };
diff --git a/vm/vm/main/cached/Serialized-implem-decl.hh b/vm/vm/main/cached/Serialized-implem-decl.hh
index b01cd62af..e612e11a4 100644
--- a/vm/vm/main/cached/Serialized-implem-decl.hh
+++ b/vm/vm/main/cached/Serialized-implem-decl.hh
@@ -3,5 +3,5 @@ class Serialized;
 template <>
 class Storage<Serialized> {
 public:
-  typedef nativeint Type;
+  typedef mozart::nativeint Type;
 };
diff --git a/vm/vm/main/cached/Serialized-implem.hh b/vm/vm/main/cached/Serialized-implem.hh
index 385e3a028..ad9c33d67 100644
--- a/vm/vm/main/cached/Serialized-implem.hh
+++ b/vm/vm/main/cached/Serialized-implem.hh
@@ -20,6 +20,6 @@ void TypeInfoOf<Serialized>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-nativeint  TypedRichNode<Serialized>::n() {
+mozart::nativeint  TypedRichNode<Serialized>::n() {
   return _self.access<Serialized>().n();
 }
diff --git a/vm/vm/main/cached/Serializer-implem-decl-after.hh b/vm/vm/main/cached/Serializer-implem-decl-after.hh
index 2d5402cbf..86ee36f77 100644
--- a/vm/vm/main/cached/Serializer-implem-decl-after.hh
+++ b/vm/vm/main/cached/Serializer-implem-decl-after.hh
@@ -38,5 +38,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::UnstableNode doSerialize(VM vm, class mozart::RichNode todo);
+  mozart::UnstableNode doSerialize(mozart::VM vm, mozart::RichNode todo);
 };
diff --git a/vm/vm/main/cached/Serializer-implem.hh b/vm/vm/main/cached/Serializer-implem.hh
index 55ea9b576..64f989168 100644
--- a/vm/vm/main/cached/Serializer-implem.hh
+++ b/vm/vm/main/cached/Serializer-implem.hh
@@ -20,6 +20,6 @@ void TypeInfoOf<Serializer>::sClone(SC sc, RichNode from, UnstableNode& to) cons
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Serializer>::doSerialize(VM vm, class mozart::RichNode todo) {
+mozart::UnstableNode  TypedRichNode<Serializer>::doSerialize(mozart::VM vm, mozart::RichNode todo) {
   return _self.access<Serializer>().doSerialize(vm, todo);
 }
diff --git a/vm/vm/main/cached/SmallInt-implem-decl-after.hh b/vm/vm/main/cached/SmallInt-implem-decl-after.hh
index 3d7ea39fa..b9578e1c0 100644
--- a/vm/vm/main/cached/SmallInt-implem-decl-after.hh
+++ b/vm/vm/main/cached/SmallInt-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<SmallInt>: public TypeInfo {
     return SmallInt::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("SmallInt", uuid(), (! ::mozart::MemWord::requiresExternalMemory<nativeint>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("SmallInt", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::nativeint>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<SmallInt>* const instance() {
     return &RawType<SmallInt>::rawType;
@@ -45,62 +45,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  nativeint value();
+  mozart::nativeint value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isNumber(VM vm);
+  bool isNumber(mozart::VM vm);
 
   inline
-  bool isInt(VM vm);
+  bool isInt(mozart::VM vm);
 
   inline
-  bool isFloat(VM vm);
+  bool isFloat(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode opposite(VM vm);
+  mozart::UnstableNode opposite(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode add(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode add(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode add(VM vm, nativeint b);
+  mozart::UnstableNode add(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode subtract(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode subtract(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode subtractValue(VM vm, nativeint b);
+  mozart::UnstableNode subtractValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode multiply(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode multiply(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode multiplyValue(VM vm, nativeint b);
+  mozart::UnstableNode multiplyValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode div(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode div(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode divValue(VM vm, nativeint b);
+  mozart::UnstableNode divValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode mod(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode mod(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode modValue(VM vm, nativeint b);
+  mozart::UnstableNode modValue(mozart::VM vm, mozart::nativeint b);
 
   inline
-  class mozart::UnstableNode abs(VM vm);
+  mozart::UnstableNode abs(mozart::VM vm);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/SmallInt-implem-decl.hh b/vm/vm/main/cached/SmallInt-implem-decl.hh
index a73d2a540..16a780841 100644
--- a/vm/vm/main/cached/SmallInt-implem-decl.hh
+++ b/vm/vm/main/cached/SmallInt-implem-decl.hh
@@ -3,5 +3,5 @@ class SmallInt;
 template <>
 class Storage<SmallInt> {
 public:
-  typedef nativeint Type;
+  typedef mozart::nativeint Type;
 };
diff --git a/vm/vm/main/cached/SmallInt-implem.hh b/vm/vm/main/cached/SmallInt-implem.hh
index 65ee35ae6..a9ddd44e2 100644
--- a/vm/vm/main/cached/SmallInt-implem.hh
+++ b/vm/vm/main/cached/SmallInt-implem.hh
@@ -31,101 +31,101 @@ int TypeInfoOf<SmallInt>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) con
 
 
 inline
-nativeint  TypedRichNode<SmallInt>::value() {
+mozart::nativeint  TypedRichNode<SmallInt>::value() {
   return _self.access<SmallInt>().value();
 }
 
 inline
-bool  TypedRichNode<SmallInt>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<SmallInt>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<SmallInt>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<SmallInt>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().compareFeatures(vm, right);
 }
 
 inline
-int  TypedRichNode<SmallInt>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<SmallInt>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().compare(_self, vm, right);
 }
 
 inline
-bool  TypedRichNode<SmallInt>::isNumber(VM vm) {
+bool  TypedRichNode<SmallInt>::isNumber(mozart::VM vm) {
   return _self.access<SmallInt>().isNumber(vm);
 }
 
 inline
-bool  TypedRichNode<SmallInt>::isInt(VM vm) {
+bool  TypedRichNode<SmallInt>::isInt(mozart::VM vm) {
   return _self.access<SmallInt>().isInt(vm);
 }
 
 inline
-bool  TypedRichNode<SmallInt>::isFloat(VM vm) {
+bool  TypedRichNode<SmallInt>::isFloat(mozart::VM vm) {
   return _self.access<SmallInt>().isFloat(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::opposite(VM vm) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::opposite(mozart::VM vm) {
   return _self.access<SmallInt>().opposite(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::add(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::add(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().add(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::add(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::add(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().add(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::subtract(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::subtract(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().subtract(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::subtractValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::subtractValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().subtractValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::multiply(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::multiply(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().multiply(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::multiplyValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::multiplyValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().multiplyValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::div(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::div(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().div(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::divValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::divValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().divValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::mod(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::mod(mozart::VM vm, mozart::RichNode right) {
   return _self.access<SmallInt>().mod(vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::modValue(VM vm, nativeint b) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::modValue(mozart::VM vm, mozart::nativeint b) {
   return _self.access<SmallInt>().modValue(vm, b);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<SmallInt>::abs(VM vm) {
+mozart::UnstableNode  TypedRichNode<SmallInt>::abs(mozart::VM vm) {
   return _self.access<SmallInt>().abs(vm);
 }
 
 inline
-void  TypedRichNode<SmallInt>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<SmallInt>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<SmallInt>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/SpaceLike-interf.hh b/vm/vm/main/cached/SpaceLike-interf.hh
index 14f801083..97cd93d84 100644
--- a/vm/vm/main/cached/SpaceLike-interf.hh
+++ b/vm/vm/main/cached/SpaceLike-interf.hh
@@ -4,7 +4,7 @@ public:
   SpaceLike(UnstableNode& self) : _self(self) {}
   SpaceLike(StableNode& self) : _self(self) {}
 
-  bool isSpace(VM vm) {
+  bool isSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().isSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -19,7 +19,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode askSpace(VM vm) {
+  mozart::UnstableNode askSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().askSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -34,7 +34,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode askVerboseSpace(VM vm) {
+  mozart::UnstableNode askVerboseSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().askVerboseSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -49,7 +49,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode mergeSpace(VM vm) {
+  mozart::UnstableNode mergeSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().mergeSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -64,7 +64,7 @@ public:
     }
   }
 
-  void commitSpace(VM vm, class mozart::RichNode value) {
+  void commitSpace(mozart::VM vm, mozart::RichNode value) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().commitSpace(vm, value);
     } else if (_self.is<FailedSpace>()) {
@@ -79,7 +79,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode cloneSpace(VM vm) {
+  mozart::UnstableNode cloneSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().cloneSpace(vm);
     } else if (_self.is<FailedSpace>()) {
@@ -94,7 +94,7 @@ public:
     }
   }
 
-  void killSpace(VM vm) {
+  void killSpace(mozart::VM vm) {
     if (_self.is<ReifiedSpace>()) {
       return _self.as<ReifiedSpace>().killSpace(vm);
     } else if (_self.is<FailedSpace>()) {
diff --git a/vm/vm/main/cached/String-implem-decl-after.hh b/vm/vm/main/cached/String-implem-decl-after.hh
index c9cb672ff..0fd0eb4ca 100644
--- a/vm/vm/main/cached/String-implem-decl-after.hh
+++ b/vm/vm/main/cached/String-implem-decl-after.hh
@@ -45,47 +45,47 @@ public:
   const LString<char> & value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compare(VM vm, class mozart::RichNode right);
+  int compare(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isString(VM vm);
+  bool isString(mozart::VM vm);
 
   inline
-  bool isByteString(VM vm);
+  bool isByteString(mozart::VM vm);
 
   inline
-  LString<char> * stringGet(VM vm);
+  LString<char> * stringGet(mozart::VM vm);
 
   inline
-  LString<unsigned char> * byteStringGet(VM vm);
+  LString<unsigned char> * byteStringGet(mozart::VM vm);
 
   inline
-  nativeint stringCharAt(VM vm, class mozart::RichNode offset);
+  mozart::nativeint stringCharAt(mozart::VM vm, mozart::RichNode offset);
 
   inline
-  class mozart::UnstableNode stringAppend(VM vm, class mozart::RichNode right);
+  mozart::UnstableNode stringAppend(mozart::VM vm, mozart::RichNode right);
 
   inline
-  class mozart::UnstableNode stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to);
+  mozart::UnstableNode stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to);
 
   inline
-  void stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end);
+  void stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end);
 
   inline
-  bool stringHasPrefix(VM vm, class mozart::RichNode prefix);
+  bool stringHasPrefix(mozart::VM vm, mozart::RichNode prefix);
 
   inline
-  bool stringHasSuffix(VM vm, class mozart::RichNode suffix);
+  bool stringHasSuffix(mozart::VM vm, mozart::RichNode suffix);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/String-implem.hh b/vm/vm/main/cached/String-implem.hh
index e73601cee..501e2a712 100644
--- a/vm/vm/main/cached/String-implem.hh
+++ b/vm/vm/main/cached/String-implem.hh
@@ -31,76 +31,76 @@ const LString<char> &  TypedRichNode<String>::value() {
 }
 
 inline
-bool  TypedRichNode<String>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<String>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<String>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<String>::compare(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<String>::compare(mozart::VM vm, mozart::RichNode right) {
   return _self.access<String>().compare(vm, right);
 }
 
 inline
-bool  TypedRichNode<String>::isString(VM vm) {
+bool  TypedRichNode<String>::isString(mozart::VM vm) {
   return _self.access<String>().isString(vm);
 }
 
 inline
-bool  TypedRichNode<String>::isByteString(VM vm) {
+bool  TypedRichNode<String>::isByteString(mozart::VM vm) {
   return _self.access<String>().isByteString(vm);
 }
 
 inline
-LString<char> *  TypedRichNode<String>::stringGet(VM vm) {
+LString<char> *  TypedRichNode<String>::stringGet(mozart::VM vm) {
   return _self.access<String>().stringGet(vm);
 }
 
 inline
-LString<unsigned char> *  TypedRichNode<String>::byteStringGet(VM vm) {
+LString<unsigned char> *  TypedRichNode<String>::byteStringGet(mozart::VM vm) {
   return _self.access<String>().byteStringGet(_self, vm);
 }
 
 inline
-nativeint  TypedRichNode<String>::stringCharAt(VM vm, class mozart::RichNode offset) {
+mozart::nativeint  TypedRichNode<String>::stringCharAt(mozart::VM vm, mozart::RichNode offset) {
   return _self.access<String>().stringCharAt(_self, vm, offset);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<String>::stringAppend(VM vm, class mozart::RichNode right) {
+mozart::UnstableNode  TypedRichNode<String>::stringAppend(mozart::VM vm, mozart::RichNode right) {
   return _self.access<String>().stringAppend(_self, vm, right);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<String>::stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to) {
+mozart::UnstableNode  TypedRichNode<String>::stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to) {
   return _self.access<String>().stringSlice(_self, vm, from, to);
 }
 
 inline
-void  TypedRichNode<String>::stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end) {
+void  TypedRichNode<String>::stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end) {
   _self.access<String>().stringSearch(_self, vm, from, needle, begin, end);
 }
 
 inline
-bool  TypedRichNode<String>::stringHasPrefix(VM vm, class mozart::RichNode prefix) {
+bool  TypedRichNode<String>::stringHasPrefix(mozart::VM vm, mozart::RichNode prefix) {
   return _self.access<String>().stringHasPrefix(vm, prefix);
 }
 
 inline
-bool  TypedRichNode<String>::stringHasSuffix(VM vm, class mozart::RichNode suffix) {
+bool  TypedRichNode<String>::stringHasSuffix(mozart::VM vm, mozart::RichNode suffix) {
   return _self.access<String>().stringHasSuffix(vm, suffix);
 }
 
 inline
-bool  TypedRichNode<String>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<String>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<String>().lookupFeature(_self, vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<String>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<String>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<String>().lookupFeature(_self, vm, feature, value);
 }
 
 inline
-void  TypedRichNode<String>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<String>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<String>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/StringLike-interf.hh b/vm/vm/main/cached/StringLike-interf.hh
index 3223fd985..51c0b5970 100644
--- a/vm/vm/main/cached/StringLike-interf.hh
+++ b/vm/vm/main/cached/StringLike-interf.hh
@@ -4,7 +4,7 @@ public:
   StringLike(UnstableNode& self) : _self(self) {}
   StringLike(StableNode& self) : _self(self) {}
 
-  bool isString(VM vm) {
+  bool isString(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().isString(vm);
     } else if (_self.is<ByteString>()) {
@@ -17,7 +17,7 @@ public:
     }
   }
 
-  bool isByteString(VM vm) {
+  bool isByteString(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().isByteString(vm);
     } else if (_self.is<ByteString>()) {
@@ -30,7 +30,7 @@ public:
     }
   }
 
-  LString<char> * stringGet(VM vm) {
+  LString<char> * stringGet(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().stringGet(vm);
     } else if (_self.is<ByteString>()) {
@@ -43,7 +43,7 @@ public:
     }
   }
 
-  LString<unsigned char> * byteStringGet(VM vm) {
+  LString<unsigned char> * byteStringGet(mozart::VM vm) {
     if (_self.is<String>()) {
       return _self.as<String>().byteStringGet(vm);
     } else if (_self.is<ByteString>()) {
@@ -56,7 +56,7 @@ public:
     }
   }
 
-  nativeint stringCharAt(VM vm, class mozart::RichNode offset) {
+  mozart::nativeint stringCharAt(mozart::VM vm, mozart::RichNode offset) {
     if (_self.is<String>()) {
       return _self.as<String>().stringCharAt(vm, offset);
     } else if (_self.is<ByteString>()) {
@@ -69,7 +69,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode stringAppend(VM vm, class mozart::RichNode right) {
+  mozart::UnstableNode stringAppend(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<String>()) {
       return _self.as<String>().stringAppend(vm, right);
     } else if (_self.is<ByteString>()) {
@@ -82,7 +82,7 @@ public:
     }
   }
 
-  class mozart::UnstableNode stringSlice(VM vm, class mozart::RichNode from, class mozart::RichNode to) {
+  mozart::UnstableNode stringSlice(mozart::VM vm, mozart::RichNode from, mozart::RichNode to) {
     if (_self.is<String>()) {
       return _self.as<String>().stringSlice(vm, from, to);
     } else if (_self.is<ByteString>()) {
@@ -95,7 +95,7 @@ public:
     }
   }
 
-  void stringSearch(VM vm, class mozart::RichNode from, class mozart::RichNode needle, class mozart::UnstableNode & begin, class mozart::UnstableNode & end) {
+  void stringSearch(mozart::VM vm, mozart::RichNode from, mozart::RichNode needle, mozart::UnstableNode & begin, mozart::UnstableNode & end) {
     if (_self.is<String>()) {
       return _self.as<String>().stringSearch(vm, from, needle, begin, end);
     } else if (_self.is<ByteString>()) {
@@ -108,7 +108,7 @@ public:
     }
   }
 
-  bool stringHasPrefix(VM vm, class mozart::RichNode prefix) {
+  bool stringHasPrefix(mozart::VM vm, mozart::RichNode prefix) {
     if (_self.is<String>()) {
       return _self.as<String>().stringHasPrefix(vm, prefix);
     } else if (_self.is<ByteString>()) {
@@ -121,7 +121,7 @@ public:
     }
   }
 
-  bool stringHasSuffix(VM vm, class mozart::RichNode suffix) {
+  bool stringHasSuffix(mozart::VM vm, mozart::RichNode suffix) {
     if (_self.is<String>()) {
       return _self.as<String>().stringHasSuffix(vm, suffix);
     } else if (_self.is<ByteString>()) {
diff --git a/vm/vm/main/cached/StructuralEquatable-interf.hh b/vm/vm/main/cached/StructuralEquatable-interf.hh
index ec5ea82dc..c4ecb1b0e 100644
--- a/vm/vm/main/cached/StructuralEquatable-interf.hh
+++ b/vm/vm/main/cached/StructuralEquatable-interf.hh
@@ -4,7 +4,7 @@ public:
   StructuralEquatable(UnstableNode& self) : _self(self) {}
   StructuralEquatable(StableNode& self) : _self(self) {}
 
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
     if (_self.is<Tuple>()) {
       return _self.as<Tuple>().equals(vm, right, stack);
     } else if (_self.is<Cons>()) {
diff --git a/vm/vm/main/cached/ThreadLike-interf.hh b/vm/vm/main/cached/ThreadLike-interf.hh
index bbe1036e2..83fb2e935 100644
--- a/vm/vm/main/cached/ThreadLike-interf.hh
+++ b/vm/vm/main/cached/ThreadLike-interf.hh
@@ -4,7 +4,7 @@ public:
   ThreadLike(UnstableNode& self) : _self(self) {}
   ThreadLike(StableNode& self) : _self(self) {}
 
-  bool isThread(VM vm) {
+  bool isThread(mozart::VM vm) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().isThread(vm);
     } else if (_self.isTransient()) {
@@ -15,7 +15,7 @@ public:
     }
   }
 
-  enum mozart::ThreadPriority getThreadPriority(VM vm) {
+  mozart::ThreadPriority getThreadPriority(mozart::VM vm) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().getThreadPriority(vm);
     } else if (_self.isTransient()) {
@@ -26,7 +26,7 @@ public:
     }
   }
 
-  void setThreadPriority(VM vm, enum mozart::ThreadPriority priority) {
+  void setThreadPriority(mozart::VM vm, mozart::ThreadPriority priority) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().setThreadPriority(vm, priority);
     } else if (_self.isTransient()) {
@@ -37,7 +37,7 @@ public:
     }
   }
 
-  void injectException(VM vm, class mozart::RichNode exception) {
+  void injectException(mozart::VM vm, mozart::RichNode exception) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().injectException(vm, exception);
     } else if (_self.isTransient()) {
diff --git a/vm/vm/main/cached/Tuple-implem-decl-after.hh b/vm/vm/main/cached/Tuple-implem-decl-after.hh
index 4ff3160a9..d20b5583e 100644
--- a/vm/vm/main/cached/Tuple-implem-decl-after.hh
+++ b/vm/vm/main/cached/Tuple-implem-decl-after.hh
@@ -48,10 +48,10 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
@@ -60,56 +60,56 @@ public:
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  class mozart::StableNode * getLabel();
+  mozart::StableNode * getLabel();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  bool hasSharpRepr(VM vm, int depth);
+  bool hasSharpRepr(mozart::VM vm, int depth);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/vm/main/cached/Tuple-implem-decl.hh b/vm/vm/main/cached/Tuple-implem-decl.hh
index c6dcd35da..c345361b0 100644
--- a/vm/vm/main/cached/Tuple-implem-decl.hh
+++ b/vm/vm/main/cached/Tuple-implem-decl.hh
@@ -3,5 +3,5 @@ class Tuple;
 template <>
 class Storage<Tuple> {
 public:
-  typedef ImplWithArray<Tuple, class mozart::StableNode> Type;
+  typedef ImplWithArray<Tuple, mozart::StableNode> Type;
 };
diff --git a/vm/vm/main/cached/Tuple-implem.hh b/vm/vm/main/cached/Tuple-implem.hh
index 0275bdd26..10130d89d 100644
--- a/vm/vm/main/cached/Tuple-implem.hh
+++ b/vm/vm/main/cached/Tuple-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Tuple>::getArraySize() {
   return _self.access<Tuple>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Tuple>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Tuple>::getElementsArray() {
   return _self.access<Tuple>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Tuple>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Tuple>::getElements(size_t i) {
   return _self.access<Tuple>().getElements(i);
 }
 
@@ -53,91 +53,91 @@ size_t  TypedRichNode<Tuple>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Tuple>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Tuple>::getElement(size_t index) {
   return _self.access<Tuple>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Tuple>::isRecord(VM vm) {
+bool  TypedRichNode<Tuple>::isRecord(mozart::VM vm) {
   return _self.access<Tuple>().isRecord(vm);
 }
 
 inline
-size_t  TypedRichNode<Tuple>::width(VM vm) {
+size_t  TypedRichNode<Tuple>::width(mozart::VM vm) {
   return _self.access<Tuple>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::arityList(mozart::VM vm) {
   return _self.access<Tuple>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::waitOr(mozart::VM vm) {
   return _self.access<Tuple>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Tuple>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Tuple>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Tuple>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Tuple>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Tuple>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Tuple>().lookupFeature(vm, feature, value);
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Tuple>::getLabel() {
+mozart::StableNode *  TypedRichNode<Tuple>::getLabel() {
   return _self.access<Tuple>().getLabel();
 }
 
 inline
-bool  TypedRichNode<Tuple>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Tuple>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Tuple>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Tuple>::isTuple(VM vm) {
+bool  TypedRichNode<Tuple>::isTuple(mozart::VM vm) {
   return _self.access<Tuple>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::label(mozart::VM vm) {
   return _self.access<Tuple>().label(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Tuple>::clone(mozart::VM vm) {
   return _self.access<Tuple>().clone(vm);
 }
 
 inline
-bool  TypedRichNode<Tuple>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Tuple>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Tuple>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Tuple>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Tuple>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Tuple>().testTuple(vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Tuple>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Tuple>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Tuple>().testLabel(vm, label);
 }
 
 inline
-void  TypedRichNode<Tuple>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Tuple>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Tuple>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-bool  TypedRichNode<Tuple>::hasSharpRepr(VM vm, int depth) {
+bool  TypedRichNode<Tuple>::hasSharpRepr(mozart::VM vm, int depth) {
   return _self.access<Tuple>().hasSharpRepr(vm, depth);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Tuple>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Tuple>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Tuple>().serialize(vm, se);
 }
diff --git a/vm/vm/main/cached/UniqueName-implem-decl-after.hh b/vm/vm/main/cached/UniqueName-implem-decl-after.hh
index f16194068..ca8a8de12 100644
--- a/vm/vm/main/cached/UniqueName-implem-decl-after.hh
+++ b/vm/vm/main/cached/UniqueName-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<UniqueName>: public TypeInfo {
     return UniqueName::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("UniqueName", uuid(), (! ::mozart::MemWord::requiresExternalMemory<unique_name_t>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("UniqueName", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::unique_name_t>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<UniqueName>* const instance() {
     return &RawType<UniqueName>::rawType;
@@ -48,62 +48,62 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  unique_name_t value();
+  mozart::unique_name_t value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/UniqueName-implem-decl.hh b/vm/vm/main/cached/UniqueName-implem-decl.hh
index b45187bb8..1b6dd0925 100644
--- a/vm/vm/main/cached/UniqueName-implem-decl.hh
+++ b/vm/vm/main/cached/UniqueName-implem-decl.hh
@@ -3,5 +3,5 @@ class UniqueName;
 template <>
 class Storage<UniqueName> {
 public:
-  typedef unique_name_t Type;
+  typedef mozart::unique_name_t Type;
 };
diff --git a/vm/vm/main/cached/UniqueName-implem.hh b/vm/vm/main/cached/UniqueName-implem.hh
index 18419f399..be5f6cbb5 100644
--- a/vm/vm/main/cached/UniqueName-implem.hh
+++ b/vm/vm/main/cached/UniqueName-implem.hh
@@ -36,101 +36,101 @@ int TypeInfoOf<UniqueName>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) c
 
 
 inline
-bool  TypedRichNode<UniqueName>::isLiteral(VM vm) {
+bool  TypedRichNode<UniqueName>::isLiteral(mozart::VM vm) {
   return _self.access<UniqueName>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<UniqueName>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<UniqueName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<UniqueName>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<UniqueName>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::isRecord(VM vm) {
+bool  TypedRichNode<UniqueName>::isRecord(mozart::VM vm) {
   return _self.access<UniqueName>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::isTuple(VM vm) {
+bool  TypedRichNode<UniqueName>::isTuple(mozart::VM vm) {
   return _self.access<UniqueName>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::label(mozart::VM vm) {
   return _self.access<UniqueName>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<UniqueName>::width(VM vm) {
+size_t  TypedRichNode<UniqueName>::width(mozart::VM vm) {
   return _self.access<UniqueName>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::arityList(mozart::VM vm) {
   return _self.access<UniqueName>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::clone(mozart::VM vm) {
   return _self.access<UniqueName>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::waitOr(mozart::VM vm) {
   return _self.access<UniqueName>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<UniqueName>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<UniqueName>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<UniqueName>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<UniqueName>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<UniqueName>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<UniqueName>().testLabel(_self, vm, label);
 }
 
 inline
-unique_name_t  TypedRichNode<UniqueName>::value() {
+mozart::unique_name_t  TypedRichNode<UniqueName>::value() {
   return _self.access<UniqueName>().value();
 }
 
 inline
-bool  TypedRichNode<UniqueName>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<UniqueName>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<UniqueName>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<UniqueName>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<UniqueName>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<UniqueName>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<UniqueName>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<UniqueName>::getPrintName(mozart::VM vm) {
   return _self.access<UniqueName>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<UniqueName>::isName(VM vm) {
+bool  TypedRichNode<UniqueName>::isName(mozart::VM vm) {
   return _self.access<UniqueName>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<UniqueName>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<UniqueName>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<UniqueName>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<UniqueName>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<UniqueName>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<UniqueName>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Unit-implem-decl-after.hh b/vm/vm/main/cached/Unit-implem-decl-after.hh
index d61f8fa7d..b37298aff 100644
--- a/vm/vm/main/cached/Unit-implem-decl-after.hh
+++ b/vm/vm/main/cached/Unit-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<Unit>: public TypeInfo {
     return Unit::uuid;
   }
 public:
-  TypeInfoOf() : TypeInfo("Unit", uuid(), (! ::mozart::MemWord::requiresExternalMemory<struct mozart::unit_t>()), false, true, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("Unit", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::unit_t>()), false, true, sbValue, 0) {}
 
   static const TypeInfoOf<Unit>* const instance() {
     return &RawType<Unit>::rawType;
@@ -48,59 +48,59 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  bool isLiteral(VM vm);
+  bool isLiteral(mozart::VM vm);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool isRecord(VM vm);
+  bool isRecord(mozart::VM vm);
 
   inline
-  bool isTuple(VM vm);
+  bool isTuple(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode label(VM vm);
+  mozart::UnstableNode label(mozart::VM vm);
 
   inline
-  size_t width(VM vm);
+  size_t width(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arityList(VM vm);
+  mozart::UnstableNode arityList(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode clone(VM vm);
+  mozart::UnstableNode clone(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode waitOr(VM vm);
+  mozart::UnstableNode waitOr(mozart::VM vm);
 
   inline
-  bool testRecord(VM vm, class mozart::RichNode arity);
+  bool testRecord(mozart::VM vm, mozart::RichNode arity);
 
   inline
-  bool testTuple(VM vm, class mozart::RichNode label, size_t width);
+  bool testTuple(mozart::VM vm, mozart::RichNode label, size_t width);
 
   inline
-  bool testLabel(VM vm, class mozart::RichNode label);
+  bool testLabel(mozart::VM vm, mozart::RichNode label);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  int compareFeatures(VM vm, class mozart::RichNode right);
+  int compareFeatures(mozart::VM vm, mozart::RichNode right);
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isName(VM vm);
+  bool isName(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Unit-implem-decl.hh b/vm/vm/main/cached/Unit-implem-decl.hh
index 27a79a997..103226762 100644
--- a/vm/vm/main/cached/Unit-implem-decl.hh
+++ b/vm/vm/main/cached/Unit-implem-decl.hh
@@ -3,5 +3,5 @@ class Unit;
 template <>
 class Storage<Unit> {
 public:
-  typedef struct mozart::unit_t Type;
+  typedef mozart::unit_t Type;
 };
diff --git a/vm/vm/main/cached/Unit-implem.hh b/vm/vm/main/cached/Unit-implem.hh
index a7fcaf0a3..74d03b44b 100644
--- a/vm/vm/main/cached/Unit-implem.hh
+++ b/vm/vm/main/cached/Unit-implem.hh
@@ -36,96 +36,96 @@ int TypeInfoOf<Unit>::compareFeatures(VM vm, RichNode lhs, RichNode rhs) const {
 
 
 inline
-bool  TypedRichNode<Unit>::isLiteral(VM vm) {
+bool  TypedRichNode<Unit>::isLiteral(mozart::VM vm) {
   return _self.access<Unit>().isLiteral(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Unit>::lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Unit>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Unit>::lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value) {
+bool  TypedRichNode<Unit>::lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value) {
   return _self.access<Unit>().lookupFeature(vm, feature, value);
 }
 
 inline
-bool  TypedRichNode<Unit>::isRecord(VM vm) {
+bool  TypedRichNode<Unit>::isRecord(mozart::VM vm) {
   return _self.access<Unit>().isRecord(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::isTuple(VM vm) {
+bool  TypedRichNode<Unit>::isTuple(mozart::VM vm) {
   return _self.access<Unit>().isTuple(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::label(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::label(mozart::VM vm) {
   return _self.access<Unit>().label(_self, vm);
 }
 
 inline
-size_t  TypedRichNode<Unit>::width(VM vm) {
+size_t  TypedRichNode<Unit>::width(mozart::VM vm) {
   return _self.access<Unit>().width(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::arityList(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::arityList(mozart::VM vm) {
   return _self.access<Unit>().arityList(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::clone(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::clone(mozart::VM vm) {
   return _self.access<Unit>().clone(_self, vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::waitOr(VM vm) {
+mozart::UnstableNode  TypedRichNode<Unit>::waitOr(mozart::VM vm) {
   return _self.access<Unit>().waitOr(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::testRecord(VM vm, class mozart::RichNode arity) {
+bool  TypedRichNode<Unit>::testRecord(mozart::VM vm, mozart::RichNode arity) {
   return _self.access<Unit>().testRecord(vm, arity);
 }
 
 inline
-bool  TypedRichNode<Unit>::testTuple(VM vm, class mozart::RichNode label, size_t width) {
+bool  TypedRichNode<Unit>::testTuple(mozart::VM vm, mozart::RichNode label, size_t width) {
   return _self.access<Unit>().testTuple(_self, vm, label, width);
 }
 
 inline
-bool  TypedRichNode<Unit>::testLabel(VM vm, class mozart::RichNode label) {
+bool  TypedRichNode<Unit>::testLabel(mozart::VM vm, mozart::RichNode label) {
   return _self.access<Unit>().testLabel(_self, vm, label);
 }
 
 inline
-bool  TypedRichNode<Unit>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<Unit>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Unit>().equals(vm, right);
 }
 
 inline
-int  TypedRichNode<Unit>::compareFeatures(VM vm, class mozart::RichNode right) {
+int  TypedRichNode<Unit>::compareFeatures(mozart::VM vm, mozart::RichNode right) {
   return _self.access<Unit>().compareFeatures(vm, right);
 }
 
 inline
-atom_t  TypedRichNode<Unit>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Unit>::getPrintName(mozart::VM vm) {
   return _self.access<Unit>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Unit>::isName(VM vm) {
+bool  TypedRichNode<Unit>::isName(mozart::VM vm) {
   return _self.access<Unit>().isName(vm);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Unit>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Unit>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Unit>().serialize(vm, se);
 }
 
 inline
-void  TypedRichNode<Unit>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Unit>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Unit>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/VMPort-implem-decl-after.hh b/vm/vm/main/cached/VMPort-implem-decl-after.hh
index b55912ad8..df62e57b0 100644
--- a/vm/vm/main/cached/VMPort-implem-decl-after.hh
+++ b/vm/vm/main/cached/VMPort-implem-decl-after.hh
@@ -5,7 +5,7 @@ class TypeInfoOf<VMPort>: public TypeInfo {
     return UUID();
   }
 public:
-  TypeInfoOf() : TypeInfo("VMPort", uuid(), (! ::mozart::MemWord::requiresExternalMemory<VMIdentifier>()), false, false, sbValue, 0) {}
+  TypeInfoOf() : TypeInfo("VMPort", uuid(), (! ::mozart::MemWord::requiresExternalMemory<mozart::VMIdentifier>()), false, false, sbValue, 0) {}
 
   static const TypeInfoOf<VMPort>* const instance() {
     return &RawType<VMPort>::rawType;
@@ -42,20 +42,20 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  VMIdentifier value();
+  mozart::VMIdentifier value();
 
   inline
-  bool equals(VM vm, class mozart::RichNode right);
+  bool equals(mozart::VM vm, mozart::RichNode right);
 
   inline
-  bool isPort(VM vm);
+  bool isPort(mozart::VM vm);
 
   inline
-  void send(VM vm, class mozart::RichNode value);
+  void send(mozart::VM vm, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode sendReceive(VM vm, class mozart::RichNode value);
+  mozart::UnstableNode sendReceive(mozart::VM vm, mozart::RichNode value);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/VMPort-implem-decl.hh b/vm/vm/main/cached/VMPort-implem-decl.hh
index 3b8e85609..ae4e9a15b 100644
--- a/vm/vm/main/cached/VMPort-implem-decl.hh
+++ b/vm/vm/main/cached/VMPort-implem-decl.hh
@@ -3,5 +3,5 @@ class VMPort;
 template <>
 class Storage<VMPort> {
 public:
-  typedef VMIdentifier Type;
+  typedef mozart::VMIdentifier Type;
 };
diff --git a/vm/vm/main/cached/VMPort-implem.hh b/vm/vm/main/cached/VMPort-implem.hh
index a092e4131..d871bdbe0 100644
--- a/vm/vm/main/cached/VMPort-implem.hh
+++ b/vm/vm/main/cached/VMPort-implem.hh
@@ -26,31 +26,31 @@ void TypeInfoOf<VMPort>::sClone(SC sc, RichNode from, UnstableNode& to) const {
 }
 
 inline
-VMIdentifier  TypedRichNode<VMPort>::value() {
+mozart::VMIdentifier  TypedRichNode<VMPort>::value() {
   return _self.access<VMPort>().value();
 }
 
 inline
-bool  TypedRichNode<VMPort>::equals(VM vm, class mozart::RichNode right) {
+bool  TypedRichNode<VMPort>::equals(mozart::VM vm, mozart::RichNode right) {
   return _self.access<VMPort>().equals(vm, right);
 }
 
 inline
-bool  TypedRichNode<VMPort>::isPort(VM vm) {
+bool  TypedRichNode<VMPort>::isPort(mozart::VM vm) {
   return _self.access<VMPort>().isPort(vm);
 }
 
 inline
-void  TypedRichNode<VMPort>::send(VM vm, class mozart::RichNode value) {
+void  TypedRichNode<VMPort>::send(mozart::VM vm, mozart::RichNode value) {
   _self.access<VMPort>().send(vm, value);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<VMPort>::sendReceive(VM vm, class mozart::RichNode value) {
+mozart::UnstableNode  TypedRichNode<VMPort>::sendReceive(mozart::VM vm, mozart::RichNode value) {
   return _self.access<VMPort>().sendReceive(vm, value);
 }
 
 inline
-void  TypedRichNode<VMPort>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<VMPort>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<VMPort>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/ValueEquatable-interf.hh b/vm/vm/main/cached/ValueEquatable-interf.hh
index 52afd20d6..548c5062e 100644
--- a/vm/vm/main/cached/ValueEquatable-interf.hh
+++ b/vm/vm/main/cached/ValueEquatable-interf.hh
@@ -4,7 +4,7 @@ public:
   ValueEquatable(UnstableNode& self) : _self(self) {}
   ValueEquatable(StableNode& self) : _self(self) {}
 
-  bool equals(VM vm, class mozart::RichNode right) {
+  bool equals(mozart::VM vm, mozart::RichNode right) {
     if (_self.is<SmallInt>()) {
       return _self.as<SmallInt>().equals(vm, right);
     } else if (_self.is<BigInt>()) {
diff --git a/vm/vm/main/cached/Variable-implem-decl-after.hh b/vm/vm/main/cached/Variable-implem-decl-after.hh
index f87779f6e..2e888e68b 100644
--- a/vm/vm/main/cached/Variable-implem-decl-after.hh
+++ b/vm/vm/main/cached/Variable-implem-decl-after.hh
@@ -38,26 +38,26 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  void addToSuspendList(VM vm, class mozart::RichNode variable);
+  void addToSuspendList(mozart::VM vm, mozart::RichNode variable);
 
   inline
-  bool isNeeded(VM vm);
+  bool isNeeded(mozart::VM vm);
 
   inline
-  void markNeeded(VM vm);
+  void markNeeded(mozart::VM vm);
 
   inline
-  void wakeUp(VM vm);
+  void wakeUp(mozart::VM vm);
 
   inline
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space);
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space);
 
   inline
-  void bind(VM vm, class mozart::RichNode src);
+  void bind(mozart::VM vm, mozart::RichNode src);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/vm/main/cached/Variable-implem.hh b/vm/vm/main/cached/Variable-implem.hh
index 1d71d6676..73cf01dda 100644
--- a/vm/vm/main/cached/Variable-implem.hh
+++ b/vm/vm/main/cached/Variable-implem.hh
@@ -26,41 +26,41 @@ void TypeInfoOf<Variable>::sClone(SC sc, RichNode from, UnstableNode& to) const
 }
 
 inline
-class mozart::Space *  TypedRichNode<Variable>::home() {
+mozart::Space *  TypedRichNode<Variable>::home() {
   return _self.access<Variable>().home();
 }
 
 inline
-void  TypedRichNode<Variable>::addToSuspendList(VM vm, class mozart::RichNode variable) {
+void  TypedRichNode<Variable>::addToSuspendList(mozart::VM vm, mozart::RichNode variable) {
   _self.access<Variable>().addToSuspendList(vm, variable);
 }
 
 inline
-bool  TypedRichNode<Variable>::isNeeded(VM vm) {
+bool  TypedRichNode<Variable>::isNeeded(mozart::VM vm) {
   return _self.access<Variable>().isNeeded(vm);
 }
 
 inline
-void  TypedRichNode<Variable>::markNeeded(VM vm) {
+void  TypedRichNode<Variable>::markNeeded(mozart::VM vm) {
   _self.access<Variable>().markNeeded(vm);
 }
 
 inline
-void  TypedRichNode<Variable>::wakeUp(VM vm) {
+void  TypedRichNode<Variable>::wakeUp(mozart::VM vm) {
   _self.access<Variable>().wakeUp(_self, vm);
 }
 
 inline
-bool  TypedRichNode<Variable>::shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+bool  TypedRichNode<Variable>::shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
   return _self.access<Variable>().shouldWakeUpUnderSpace(vm, space);
 }
 
 inline
-void  TypedRichNode<Variable>::bind(VM vm, class mozart::RichNode src) {
+void  TypedRichNode<Variable>::bind(mozart::VM vm, mozart::RichNode src) {
   _self.access<Variable>().bind(_self, vm, src);
 }
 
 inline
-void  TypedRichNode<Variable>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Variable>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Variable>().printReprToStream(vm, out, depth, width);
 }
diff --git a/vm/vm/main/cached/Wakeable-interf.hh b/vm/vm/main/cached/Wakeable-interf.hh
index 087dbf17a..b6df799ce 100644
--- a/vm/vm/main/cached/Wakeable-interf.hh
+++ b/vm/vm/main/cached/Wakeable-interf.hh
@@ -4,7 +4,7 @@ public:
   Wakeable(UnstableNode& self) : _self(self) {}
   Wakeable(StableNode& self) : _self(self) {}
 
-  void wakeUp(VM vm) {
+  void wakeUp(mozart::VM vm) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().wakeUp(vm);
     } else if (_self.is<Variable>()) {
@@ -16,7 +16,7 @@ public:
     }
   }
 
-  bool shouldWakeUpUnderSpace(VM vm, class mozart::Space * space) {
+  bool shouldWakeUpUnderSpace(mozart::VM vm, mozart::Space * space) {
     if (_self.is<ReifiedThread>()) {
       return _self.as<ReifiedThread>().shouldWakeUpUnderSpace(vm, space);
     } else if (_self.is<Variable>()) {
diff --git a/vm/vm/main/cached/WeakReference-implem-decl-after.hh b/vm/vm/main/cached/WeakReference-implem-decl-after.hh
index 37ab624c3..cc71e5afa 100644
--- a/vm/vm/main/cached/WeakReference-implem-decl-after.hh
+++ b/vm/vm/main/cached/WeakReference-implem-decl-after.hh
@@ -34,5 +34,5 @@ public:
   explicit TypedRichNode(RichNode self) : BaseTypedRichNode(self) {}
 
   inline
-  class mozart::StableNode * getUnderlying();
+  mozart::StableNode * getUnderlying();
 };
diff --git a/vm/vm/main/cached/WeakReference-implem-decl.hh b/vm/vm/main/cached/WeakReference-implem-decl.hh
index 5f368840a..e5d4be79d 100644
--- a/vm/vm/main/cached/WeakReference-implem-decl.hh
+++ b/vm/vm/main/cached/WeakReference-implem-decl.hh
@@ -3,5 +3,5 @@ class WeakReference;
 template <>
 class Storage<WeakReference> {
 public:
-  typedef class mozart::StableNode * Type;
+  typedef mozart::StableNode * Type;
 };
diff --git a/vm/vm/main/cached/WeakReference-implem.hh b/vm/vm/main/cached/WeakReference-implem.hh
index 137598365..28d74518f 100644
--- a/vm/vm/main/cached/WeakReference-implem.hh
+++ b/vm/vm/main/cached/WeakReference-implem.hh
@@ -6,9 +6,7 @@ void TypeInfoOf<WeakReference>::gCollect(GC gc, RichNode from, StableNode& to) c
 
 void TypeInfoOf<WeakReference>::gCollect(GC gc, RichNode from, UnstableNode& to) const {
   assert(from.type() == type());
-  StableNode* stable = new (gc->vm) StableNode;
-  to.make<Reference>(gc->vm, stable);
-  stable->make<WeakReference>(gc->vm, gc, from.access<WeakReference>());
+  to.make<WeakReference>(gc->vm, gc, from.access<WeakReference>());
 }
 
 void TypeInfoOf<WeakReference>::sClone(SC sc, RichNode from, StableNode& to) const {
@@ -22,6 +20,6 @@ void TypeInfoOf<WeakReference>::sClone(SC sc, RichNode from, UnstableNode& to) c
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<WeakReference>::getUnderlying() {
+mozart::StableNode *  TypedRichNode<WeakReference>::getUnderlying() {
   return _self.access<WeakReference>().getUnderlying();
 }
diff --git a/vm/vm/main/cached/WithPrintName-interf.hh b/vm/vm/main/cached/WithPrintName-interf.hh
index 6eb844d41..07f7304a9 100644
--- a/vm/vm/main/cached/WithPrintName-interf.hh
+++ b/vm/vm/main/cached/WithPrintName-interf.hh
@@ -4,7 +4,7 @@ public:
   WithPrintName(UnstableNode& self) : _self(self) {}
   WithPrintName(StableNode& self) : _self(self) {}
 
-  atom_t getPrintName(VM vm) {
+  mozart::atom_t getPrintName(mozart::VM vm) {
     if (_self.is<Abstraction>()) {
       return _self.as<Abstraction>().getPrintName(vm);
     } else if (_self.is<BuiltinProcedure>()) {
@@ -21,7 +21,7 @@ public:
       return _self.as<Unit>().getPrintName(vm);
     } else {
       if (_self.is< ::mozart::ReflectiveEntity>()) {
-        atom_t _result;
+        mozart::atom_t _result;
         if (_self.as< ::mozart::ReflectiveEntity>().reflectiveCall(vm, "$intf$::WithPrintName::getPrintName", "getPrintName", ::mozart::ozcalls::out(_result)))
           return _result;
       }