Index: libcfa/src/collections/list.hfa
===================================================================
--- libcfa/src/collections/list.hfa	(revision 9c1880b329cf652881b827acd386b472eac48b20)
+++ libcfa/src/collections/list.hfa	(revision 29c6a7dfeec121a0157cfbef76e8fc4c3c416947)
@@ -80,18 +80,80 @@
 // part), by failing fast.
 
-#if defined( __x86_64 )
-	// Preferred case: tag in the most-significant bit.  Dereference has been shown to segfault consistently.
-	// Maintenance should list more architectures as "ok" here, to let them use the preferred case, when valid.
-	#define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
-#else
-	// Fallback case: tag in the least-significant bit.  Dereference will often give an alignment error, but may not,
-	// e.g. if accessing a char-typed member.  32-bit x86 uses the most- significant bit for real room on the heap.
-	#define ORIGIN_TAG_BITNO 0
+#ifdef __EXPERIMENTAL_DISABLE_OTAG__ // Perf experimention alt mode
+
+    // With origin tagging disabled, iteration never reports "no more elements."
+    // In this mode, the list API is buggy.
+    // This mode is used to quantify the cost of the normal tagging scheme.
+
+    #define ORIGIN_TAG_SET(p)   (p)
+    #define ORIGIN_TAG_CLEAR(p) (p)
+    #define ORIGIN_TAG_QUERY(p) 0
+    #define ORIGIN_TAG_ASGN(p, v) (p)
+    #define ORIGIN_TAG_EITHER(p, v) (p)
+    #define ORIGIN_TAG_NEQ(v1, v2) 0
+
+#else // Normal
+
+    #if defined( __x86_64 )
+        // Preferred case: tag in the most-significant bit.  Dereference
+        // has been shown to segfault consistently.  Maintenance should
+        // list more architectures as "ok" here, to let them use the
+        // preferred case, when valid.
+        #define ORIGIN_TAG_BITNO ( 8 * sizeof( size_t ) - 1 )
+    #else
+        // Fallback case: tag in the least-significant bit.  Dereference
+        // will often give an alignment error, but may not, e.g. if
+        // accessing a char-typed member.  32-bit x86 uses the most-
+        // significant bit for real room on the heap.
+        #define ORIGIN_TAG_BITNO 0
+    #endif
+
+    #define ORIGIN_TAG_MASK (((size_t)1) << ORIGIN_TAG_BITNO)
+
+    #define ORIGIN_TAG_SET(p) ((p) |  ORIGIN_TAG_MASK)
+    #define ORIGIN_TAG_CLEAR(p) ((p) & ~ORIGIN_TAG_MASK)
+    #define ORIGIN_TAG_QUERY(p) ((p) &  ORIGIN_TAG_MASK)
+
+    #define ORIGIN_TAG_ASGN(p, v) ( \
+        verify( ! ORIGIN_TAG_QUERY(p) && "p had no tagbit" ), \
+        ORIGIN_TAG_EITHER((p), (v)) \
+    )
+
+    #define ORIGIN_TAG_EITHER(p, v) ( \
+        verify( ! ORIGIN_TAG_CLEAR(v) && "v is a pure tagbit" ), \
+        ( (p) | (v) ) \
+    )
+
+    #define ORIGIN_TAG_NEQ(v1, v2) ( \
+        verify( ! ORIGIN_TAG_CLEAR(v1) && "v1 is a pure tagbit" ), \
+        verify( ! ORIGIN_TAG_CLEAR(v2) && "v2 is a pure tagbit" ), \
+        ( (v1) ^ (v2) ) \
+    )
+
 #endif
-#define ORIGIN_TAG_MASK (((size_t)1) << ORIGIN_TAG_BITNO)
-
-#define ORIGIN_TAG_SET( p )   ((p) |  ORIGIN_TAG_MASK)
-#define ORIGIN_TAG_CLEAR( p ) ((p) & ~ORIGIN_TAG_MASK)
-#define ORIGIN_TAG_QUERY( p ) ((p) &  ORIGIN_TAG_MASK)
+
+
+
+#ifdef __EXPERIMENTAL_LOOSE_SINGLES__ // Perf experimention alt mode
+
+    // In loose-singles mode, the ability to answer an "is listed" query is disabled, as is "to insert an element,
+    // it must not be listed already" checking.  The user must know separately whether an element is listed.
+    // Other than inserting it, any list-api action on an unlisted element is undefined.  Notably, list iteration
+    // starting from an unlisted element is not defined to respond "no more elements," and may instead continue
+    // iterating from a formerly occupied list position.  This mode matches LQ usage.
+
+    #define NOLOOSE(...)
+    #define LOOSEONLY(...) __VA_ARGS__
+
+#else // Normal
+
+    #define NOLOOSE(...) __VA_ARGS__
+    #define LOOSEONLY(...)
+
+#endif
+
+
+
+
 
 forall( tE & ) {
@@ -102,5 +164,7 @@
 
 	static inline void ?{}( dlink( tE ) & this ) {
+	  NOLOOSE(
 		this.next = this.prev = 0p;
+	  )
 	}
 
@@ -129,7 +193,13 @@
 static inline forall( tE &, tLinks & | embedded( tE, tLinks, dlink( tE ) ) ) {
 	bool isListed( tE & node ) {
+      NOLOOSE(
 		verify( &node != 0p );
 		dlink( tE ) & node_links = node`inner;
 		return (node_links.prev != 0p) || (node_links.next != 0p);
+	  )
+	  LOOSEONLY(
+        verify(false && "isListed is undefined");
+		return true;
+	  )
 	}
 
@@ -157,7 +227,8 @@
 
 		dlink( tE ) & linkToInsert = node`inner;
-
+      NOLOOSE(
 		verify( linkToInsert.next == 0p );
 		verify( linkToInsert.prev == 0p );
+	  )
 
 		tE & list_pos_elem = *(tE *)ORIGIN_TAG_CLEAR( (size_t)&before );
@@ -180,7 +251,8 @@
 
 		dlink( tE ) & linkToInsert = node`inner;
-
+      NOLOOSE(
 		verify( linkToInsert.prev == 0p );
 		verify( linkToInsert.next == 0p );
+	  )
 
 		tE & list_pos_elem = *(tE *)ORIGIN_TAG_CLEAR( (size_t)&after );
@@ -211,8 +283,11 @@
 		before_links.next = &after_raw;
 		after_links.prev = &before_raw;
+
+      NOLOOSE(
 		asm( "" : : : "memory" );
 		list_pos_links.prev = 0p;
 		list_pos_links.next = 0p;
 		asm( "" : : : "memory" );
+	  )
 		return node;
 	}
Index: libcfa/src/stdhdr/assert.h
===================================================================
--- libcfa/src/stdhdr/assert.h	(revision 9c1880b329cf652881b827acd386b472eac48b20)
+++ libcfa/src/stdhdr/assert.h	(revision 29c6a7dfeec121a0157cfbef76e8fc4c3c416947)
@@ -38,8 +38,8 @@
 	#define warnf( expr, fmt, ... ) ({ static bool check_once##__LINE__ = false; if( false == check_once##__LINE__ && false == (expr)) { check_once##__LINE__ = true; __assert_warn_f(__VSTRINGIFY__(expr), __FILE__, __LINE__, __PRETTY_FUNCTION__, fmt, ## __VA_ARGS__ ); } })
 #else
-	#define verify(x)
-	#define verifyf(x, ...)
-	#define verifyfail(...)
-	#define warnf( expr, fmt, ... )
+	#define verify(x) 0
+	#define verifyf(x, ...) 0
+	#define verifyfail(...) 0
+	#define warnf( expr, fmt, ... ) 0
 #endif