Index: libcfa/src/memory.cfa
===================================================================
--- libcfa/src/memory.cfa	(revision 352cbc20a6de0f18d4b8f52d721bab8a03bbf392)
+++ libcfa/src/memory.cfa	(revision 8be729fd71ad78ef553d5dce1521072429906e90)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jun  2 16:48:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun  3 12:30:00 2020
-// Update Count     : 0
+// Last Modified On : Mon Feb  1 16:10:00 2021
+// Update Count     : 1
 //
 
@@ -56,9 +56,9 @@
 }
 
-forall(T & | sized(T) | { void ^?{}(T &); })
+forall(T & | sized(T))
 void ?{}(counter_ptr(T) & this, counter_ptr(T) that) {
 	// `that` is a copy but it should have neither a constructor
 	// nor destructor run on it so it shouldn't need adjustment.
-	internal_decrement(this);
+	//internal_decrement(this);
 	internal_copy(this, that);
 }
@@ -66,5 +66,7 @@
 forall(T & | sized(T), Args... | { void ?{}(T&, Args); })
 void ?{}(counter_ptr(T) & this, Args args) {
-	this.data = (counter_data(T)*)new(args);
+	this.data = malloc();
+	this.data->counter = 1;
+	(this.data->object){args};
 }
 
@@ -126,5 +128,6 @@
 forall(T & | sized(T), Args... | { void ?{}(T &, Args); })
 void ?{}(unique_ptr(T) & this, Args args) {
-	this.data = (T *)new(args);
+	this.data = malloc();
+	(*this.data){args};
 }
 
Index: libcfa/src/memory.hfa
===================================================================
--- libcfa/src/memory.hfa	(revision 352cbc20a6de0f18d4b8f52d721bab8a03bbf392)
+++ libcfa/src/memory.hfa	(revision 8be729fd71ad78ef553d5dce1521072429906e90)
@@ -10,6 +10,6 @@
 // Created On       : Tue Jun  2 16:48:00 2020
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Jun  3 12:29:00 2020
-// Update Count     : 0
+// Last Modified On : Fri Jan 29 15:52:00 2021
+// Update Count     : 1
 //
 
@@ -17,73 +17,86 @@
 
 // Internal data object.
-forall(T & | sized(T)) {
-	struct counter_data {
-		unsigned int counter;
-		T object;
-	};
+forall(T & | sized(T))
+struct counter_data {
+	unsigned int counter;
+	T object;
+};
 
-	forall(Args... | { void ?{}(T &, Args); })
-	void ?{}(counter_data(T) & this, Args args);
+forall(T & | sized(T), Args... | { void ?{}(T &, Args); })
+void ?{}(counter_data(T) & this, Args args);
 
-	forall( | { void ^?{}(T &); })
-	void ^?{}(counter_data(T) & this);
-}
+forall(T & | sized(T) | { void ^?{}(T &); })
+void ^?{}(counter_data(T) & this);
 
 // This is one of many pointers keeping this alive.
-forall(T & | sized(T)) {
-	struct counter_ptr {
-		counter_data(T) * data;
-	};
+forall(T & | sized(T))
+struct counter_ptr {
+	counter_data(T) * data;
+};
 
-	void ?{}(counter_ptr(T) & this);
-	void ?{}(counter_ptr(T) & this, zero_t);
-	forall( | { void ^?{}(T &); })
-	void ?{}(counter_ptr(T) & this, counter_ptr(T) that);
-	forall(Args... | { void ?{}(T&, Args); })
-	void ?{}(counter_ptr(T) & this, Args args);
+forall(T & | sized(T))
+void ?{}(counter_ptr(T) & this);
+forall(T & | sized(T))
+void ?{}(counter_ptr(T) & this, zero_t);
+forall(T & | sized(T))
+void ?{}(counter_ptr(T) & this, counter_ptr(T) that);
+forall(T & | sized(T), Args... | { void ?{}(T&, Args); })
+void ?{}(counter_ptr(T) & this, Args args);
 
-	forall( | { void ^?{}(T &); })
-	void ^?{}(counter_ptr(T) & this);
+forall(T & | sized(T) | { void ^?{}(T &); })
+void ^?{}(counter_ptr(T) & this);
 
-	T & *?(counter_ptr(T) & this);
+forall(T & | sized(T))
+T & *?(counter_ptr(T) & this);
 
-	forall( | { void ^?{}(T &); })
-	void ?=?(counter_ptr(T) & this, counter_ptr(T) that);
-	forall( | { void ^?{}(T &); })
-	void ?=?(counter_ptr(T) & this, zero_t);
+forall(T & | sized(T) | { void ^?{}(T &); })
+void ?=?(counter_ptr(T) & this, counter_ptr(T) that);
+forall(T & | sized(T) | { void ^?{}(T &); })
+void ?=?(counter_ptr(T) & this, zero_t);
 
-	int ?==?(counter_ptr(T) const & this, counter_ptr(T) const & that);
-	int ?!=?(counter_ptr(T) const & this, counter_ptr(T) const & that);
-	int ?==?(counter_ptr(T) const & this, zero_t);
-	int ?!=?(counter_ptr(T) const & this, zero_t);
-}
+forall(T & | sized(T))
+int ?==?(counter_ptr(T) const & this, counter_ptr(T) const & that);
+forall(T & | sized(T))
+int ?!=?(counter_ptr(T) const & this, counter_ptr(T) const & that);
+forall(T & | sized(T))
+int ?==?(counter_ptr(T) const & this, zero_t);
+forall(T & | sized(T))
+int ?!=?(counter_ptr(T) const & this, zero_t);
 
 // This is the only pointer that keeps this alive.
-forall(T &) {
-	struct unique_ptr {
-		T * data;
-	};
+forall(T &)
+struct unique_ptr {
+	T * data;
+};
 
-	void ?{}(unique_ptr(T) & this);
-	void ?{}(unique_ptr(T) & this, zero_t);
-	void ?{}(unique_ptr(T) & this, unique_ptr(T) that) = void;
-	forall( | sized(T), Args... | { void ?{}(T &, Args); })
-	void ?{}(unique_ptr(T) & this, Args args);
+forall(T &)
+void ?{}(unique_ptr(T) & this);
+forall(T &)
+void ?{}(unique_ptr(T) & this, zero_t);
+forall(T &)
+void ?{}(unique_ptr(T) & this, unique_ptr(T) that) = void;
+forall(T & | sized(T), Args... | { void ?{}(T &, Args); })
+void ?{}(unique_ptr(T) & this, Args args);
 
-	forall( | { void ^?{}(T &); })
-	void ^?{}(unique_ptr(T) & this);
+forall(T & | { void ^?{}(T &); })
+void ^?{}(unique_ptr(T) & this);
 
-	T & *?(unique_ptr(T) & this);
+forall(T & )
+T & *?(unique_ptr(T) & this);
 
-	void ?=?(unique_ptr(T) & this, unique_ptr(T) that) = void;
-	forall( | { void ^?{}(T &); })
-	void ?=?(unique_ptr(T) & this, zero_t);
+forall(T &)
+void ?=?(unique_ptr(T) & this, unique_ptr(T) that) = void;
+forall(T & | { void ^?{}(T &); })
+void ?=?(unique_ptr(T) & this, zero_t);
 
-	forall( | { void ^?{}(T &); })
-	void move(unique_ptr(T) & this, unique_ptr(T) & that);
+forall(T & | { void ^?{}(T &); })
+void move(unique_ptr(T) & this, unique_ptr(T) & that);
 
-	int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that);
-	int ?!=?(unique_ptr(T) const & this, unique_ptr(T) const & that);
-	int ?==?(unique_ptr(T) const & this, zero_t);
-	int ?!=?(unique_ptr(T) const & this, zero_t);
-}
+forall(T &)
+int ?==?(unique_ptr(T) const & this, unique_ptr(T) const & that);
+forall(T &)
+int ?!=?(unique_ptr(T) const & this, unique_ptr(T) const & that);
+forall(T &)
+int ?==?(unique_ptr(T) const & this, zero_t);
+forall(T &)
+int ?!=?(unique_ptr(T) const & this, zero_t);