Index: libcfa/src/fstream.cfa
===================================================================
--- libcfa/src/fstream.cfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/fstream.cfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  1 21:12:15 2021
-// Update Count     : 424
+// Last Modified On : Tue Apr 20 19:04:46 2021
+// Update Count     : 425
 //
 
@@ -31,12 +31,12 @@
 
 void ?{}( ofstream & os, void * file ) {
-	os.$file = file;
-	os.$sepDefault = true;
-	os.$sepOnOff = false;
-	os.$nlOnOff = true;
-	os.$prt = false;
-	os.$sawNL = false;
-	os.$acquired = false;
-	$sepSetCur( os, sepGet( os ) );
+	os.file$ = file;
+	os.sepDefault$ = true;
+	os.sepOnOff$ = false;
+	os.nlOnOff$ = true;
+	os.prt$ = false;
+	os.sawNL$ = false;
+	os.acquired$ = false;
+	sepSetCur$( os, sepGet( os ) );
 	sepSet( os, " " );
 	sepSetTuple( os, ", " );
@@ -44,17 +44,17 @@
 
 // private
-bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
-void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
-void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
-const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
-void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
-bool $getNL( ofstream & os ) { return os.$sawNL; }
-void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
-bool $getANL( ofstream & os ) { return os.$nlOnOff; }
-bool $getPrt( ofstream & os ) { return os.$prt; }
-void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
+bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ofstream & os ) { return os.sawNL$; }
+void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ofstream & os ) { return os.prt$; }
+void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
 
 // public
-void ?{}( ofstream & os ) { os.$file = 0p; }
+void ?{}( ofstream & os ) { os.file$ = 0p; }
 
 void ?{}( ofstream & os, const char name[], const char mode[] ) {
@@ -70,52 +70,52 @@
 } // ^?{}
 
-void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
-void sepOff( ofstream & os ) { os.$sepOnOff = false; }
+void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
+void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
 
 bool sepDisable( ofstream & os ) {
-	bool temp = os.$sepDefault;
-	os.$sepDefault = false;
-	$sepReset( os );
+	bool temp = os.sepDefault$;
+	os.sepDefault$ = false;
+	sepReset$( os );
 	return temp;
 } // sepDisable
 
 bool sepEnable( ofstream & os ) {
-	bool temp = os.$sepDefault;
-	os.$sepDefault = true;
-	if ( os.$sepOnOff ) $sepReset( os );				// start of line ?
+	bool temp = os.sepDefault$;
+	os.sepDefault$ = true;
+	if ( os.sepOnOff$ ) sepReset$( os );				// start of line ?
 	return temp;
 } // sepEnable
 
-void nlOn( ofstream & os ) { os.$nlOnOff = true; }
-void nlOff( ofstream & os ) { os.$nlOnOff = false; }
-
-const char * sepGet( ofstream & os ) { return os.$separator; }
+void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
+
+const char * sepGet( ofstream & os ) { return os.separator$; }
 void sepSet( ofstream & os, const char s[] ) {
 	assert( s );
-	strncpy( os.$separator, s, sepSize - 1 );
-	os.$separator[sepSize - 1] = '\0';
+	strncpy( os.separator$, s, sepSize - 1 );
+	os.separator$[sepSize - 1] = '\0';
 } // sepSet
 
-const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
+const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; }
 void sepSetTuple( ofstream & os, const char s[] ) {
 	assert( s );
-	strncpy( os.$tupleSeparator, s, sepSize - 1 );
-	os.$tupleSeparator[sepSize - 1] = '\0';
+	strncpy( os.tupleSeparator$, s, sepSize - 1 );
+	os.tupleSeparator$[sepSize - 1] = '\0';
 } // sepSet
 
 void ends( ofstream & os ) {
-	if ( $getANL( os ) ) nl( os );
-	else $setPrt( os, false );							// turn off
+	if ( getANL$( os ) ) nl( os );
+	else setPrt$( os, false );							// turn off
 	if ( &os == &exit ) exit( EXIT_FAILURE );
 	if ( &os == &abort ) abort();
-	if ( os.$acquired ) { os.$acquired = false; release( os ); }
+	if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
 
 int fail( ofstream & os ) {
-	return os.$file == 0 || ferror( (FILE *)(os.$file) );
+	return os.file$ == 0 || ferror( (FILE *)(os.file$) );
 } // fail
 
 int flush( ofstream & os ) {
-	return fflush( (FILE *)(os.$file) );
+	return fflush( (FILE *)(os.file$) );
 } // flush
 
@@ -136,11 +136,11 @@
 
 void close( ofstream & os ) {
-  if ( (FILE *)(os.$file) == 0p ) return;
-  if ( (FILE *)(os.$file) == (FILE *)stdout || (FILE *)(os.$file) == (FILE *)stderr ) return;
-
-	if ( fclose( (FILE *)(os.$file) ) == EOF ) {
+  if ( (FILE *)(os.file$) == 0p ) return;
+  if ( (FILE *)(os.file$) == (FILE *)stdout || (FILE *)(os.file$) == (FILE *)stderr ) return;
+
+	if ( fclose( (FILE *)(os.file$) ) == EOF ) {
 		abort | IO_MSG "close output" | nl | strerror( errno );
 	} // if
-	os.$file = 0p;
+	os.file$ = 0p;
 } // close
 
@@ -150,5 +150,5 @@
 	} // if
 
-	if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
+	if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
 		abort | IO_MSG "write" | nl | strerror( errno );
 	} // if
@@ -159,7 +159,7 @@
 	va_list args;
 	va_start( args, format );
-	int len = vfprintf( (FILE *)(os.$file), format, args );
+	int len = vfprintf( (FILE *)(os.file$), format, args );
 	if ( len == EOF ) {
-		if ( ferror( (FILE *)(os.$file) ) ) {
+		if ( ferror( (FILE *)(os.file$) ) ) {
 			abort | IO_MSG "invalid write";
 		} // if
@@ -167,20 +167,20 @@
 	va_end( args );
 
-	$setPrt( os, true );								// called in output cascade
-	$sepReset( os );									// reset separator
+	setPrt$( os, true );								// called in output cascade
+	sepReset$( os );									// reset separator
 	return len;
 } // fmt
 
 inline void acquire( ofstream & os ) {
-	lock( os.$lock );
-	if ( ! os.$acquired ) os.$acquired = true;
-	else unlock( os.$lock );
+	lock( os.lock$ );
+	if ( ! os.acquired$ ) os.acquired$ = true;
+	else unlock( os.lock$ );
 } // acquire
 
 inline void release( ofstream & os ) {
-	unlock( os.$lock );
+	unlock( os.lock$ );
 } // release
 
-void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.$lock ); }
+void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
 void ^?{}( osacquire & acq ) { release( acq.os ); }
 
@@ -204,11 +204,11 @@
 // private
 void ?{}( ifstream & is, void * file ) {
-	is.$file = file;
-	is.$nlOnOff = false;
-	is.$acquired = false;
+	is.file$ = file;
+	is.nlOnOff$ = false;
+	is.acquired$ = false;
 } // ?{}
 
 // public
-void ?{}( ifstream & is ) { is.$file = 0p; }
+void ?{}( ifstream & is ) { is.file$ = 0p; }
 
 void ?{}( ifstream & is, const char name[], const char mode[] ) {
@@ -224,18 +224,18 @@
 } // ^?{}
 
-void nlOn( ifstream & os ) { os.$nlOnOff = true; }
-void nlOff( ifstream & os ) { os.$nlOnOff = false; }
-bool getANL( ifstream & os ) { return os.$nlOnOff; }
+void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff$; }
 
 int fail( ifstream & is ) {
-	return is.$file == 0p || ferror( (FILE *)(is.$file) );
+	return is.file$ == 0p || ferror( (FILE *)(is.file$) );
 } // fail
 
 void ends( ifstream & is ) {
-	if ( is.$acquired ) { is.$acquired = false; release( is ); }
+	if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
 } // ends
 
 int eof( ifstream & is ) {
-	return feof( (FILE *)(is.$file) );
+	return feof( (FILE *)(is.file$) );
 } // eof
 
@@ -248,5 +248,5 @@
 	} // if
 	#endif // __CFA_DEBUG__
-	is.$file = file;
+	is.file$ = file;
 } // open
 
@@ -256,11 +256,11 @@
 
 void close( ifstream & is ) {
-  if ( (FILE *)(is.$file) == 0p ) return;
-  if ( (FILE *)(is.$file) == (FILE *)stdin ) return;
-
-	if ( fclose( (FILE *)(is.$file) ) == EOF ) {
+  if ( (FILE *)(is.file$) == 0p ) return;
+  if ( (FILE *)(is.file$) == (FILE *)stdin ) return;
+
+	if ( fclose( (FILE *)(is.file$) ) == EOF ) {
 		abort | IO_MSG "close input" | nl | strerror( errno );
 	} // if
-	is.$file = 0p;
+	is.file$ = 0p;
 } // close
 
@@ -270,5 +270,5 @@
 	} // if
 
-	if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
+	if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
 		abort | IO_MSG "read" | nl | strerror( errno );
 	} // if
@@ -281,5 +281,5 @@
 	} // if
 
-	if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
+	if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
 		abort | IO_MSG "ungetc" | nl | strerror( errno );
 	} // if
@@ -291,7 +291,7 @@
 
 	va_start( args, format );
-	int len = vfscanf( (FILE *)(is.$file), format, args );
+	int len = vfscanf( (FILE *)(is.file$), format, args );
 	if ( len == EOF ) {
-		if ( ferror( (FILE *)(is.$file) ) ) {
+		if ( ferror( (FILE *)(is.file$) ) ) {
 			abort | IO_MSG "invalid read";
 		} // if
@@ -302,14 +302,14 @@
 
 inline void acquire( ifstream & is ) {
-	lock( is.$lock );
-	if ( ! is.$acquired ) is.$acquired = true;
-	else unlock( is.$lock );
+	lock( is.lock$ );
+	if ( ! is.acquired$ ) is.acquired$ = true;
+	else unlock( is.lock$ );
 } // acquire
 
 inline void release( ifstream & is ) {
-	unlock( is.$lock );
+	unlock( is.lock$ );
 } // release
 
-void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.$lock ); }
+void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
 void ^?{}( isacquire & acq ) { release( acq.is ); }
 
Index: libcfa/src/fstream.hfa
===================================================================
--- libcfa/src/fstream.hfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/fstream.hfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar  1 22:45:08 2021
-// Update Count     : 217
+// Last Modified On : Tue Apr 20 19:04:12 2021
+// Update Count     : 218
 //
 
@@ -26,28 +26,28 @@
 enum { sepSize = 16 };
 struct ofstream {
-	void * $file;
-	bool $sepDefault;
-	bool $sepOnOff;
-	bool $nlOnOff;
-	bool $prt;											// print text
-	bool $sawNL;
-	const char * $sepCur;
-	char $separator[sepSize];
-	char $tupleSeparator[sepSize];
-	multiple_acquisition_lock $lock;
-	bool $acquired;
+	void * file$;
+	bool sepDefault$;
+	bool sepOnOff$;
+	bool nlOnOff$;
+	bool prt$;											// print text
+	bool sawNL$;
+	const char * sepCur$;
+	char separator$[sepSize];
+	char tupleSeparator$[sepSize];
+	multiple_acquisition_lock lock$;
+	bool acquired$;
 }; // ofstream
 
 // private
-bool $sepPrt( ofstream & );
-void $sepReset( ofstream & );
-void $sepReset( ofstream &, bool );
-const char * $sepGetCur( ofstream & );
-void $sepSetCur( ofstream &, const char [] );
-bool $getNL( ofstream & );
-void $setNL( ofstream &, bool );
-bool $getANL( ofstream & );
-bool $getPrt( ofstream & );
-void $setPrt( ofstream &, bool );
+bool sepPrt$( ofstream & );
+void sepReset$( ofstream & );
+void sepReset$( ofstream &, bool );
+const char * sepGetCur$( ofstream & );
+void sepSetCur$( ofstream &, const char [] );
+bool getNL$( ofstream & );
+void setNL$( ofstream &, bool );
+bool getANL$( ofstream & );
+bool getPrt$( ofstream & );
+void setPrt$( ofstream &, bool );
 
 // public
@@ -94,8 +94,8 @@
 
 struct ifstream {
-	void * $file;
-	bool $nlOnOff;
-	multiple_acquisition_lock $lock;
-	bool $acquired;
+	void * file$;
+	bool nlOnOff$;
+	multiple_acquisition_lock lock$;
+	bool acquired$;
 }; // ifstream
 
Index: libcfa/src/gmp.hfa
===================================================================
--- libcfa/src/gmp.hfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/gmp.hfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Feb  9 09:56:54 2020
-// Update Count     : 31
+// Last Modified On : Tue Apr 20 20:59:21 2021
+// Update Count     : 32
 //
 
@@ -263,5 +263,5 @@
 	forall( ostype & | ostream( ostype ) ) {
 		ostype & ?|?( ostype & os, Int mp ) {
-			if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+			if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 			gmp_printf( "%Zd", mp.mpz );
 			sepOn( os );
Index: libcfa/src/heap.cfa
===================================================================
--- libcfa/src/heap.cfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/heap.cfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Mar 14 10:39:24 2021
-// Update Count     : 1032
+// Last Modified On : Tue Apr 20 21:20:48 2021
+// Update Count     : 1033
 //
 
@@ -1128,5 +1128,5 @@
 
 	// Set the alignment for an the allocation and return previous alignment or 0 if no alignment.
-	size_t $malloc_alignment_set( void * addr, size_t alignment ) {
+	size_t malloc_alignment_set$( void * addr, size_t alignment ) {
 	  if ( unlikely( addr == 0p ) ) return libAlign();	// minimum alignment
 		size_t ret;
@@ -1139,5 +1139,5 @@
 		} // if
 		return ret;
-	} // $malloc_alignment_set
+	} // malloc_alignment_set$
 
 
@@ -1153,5 +1153,5 @@
 
 	// Set allocation is zero filled and return previous zero filled.
-	bool $malloc_zero_fill_set( void * addr ) {
+	bool malloc_zero_fill_set$( void * addr ) {
 	  if ( unlikely( addr == 0p ) ) return false;		// null allocation is not zero fill
 		HeapManager.Storage.Header * header = headerAddr( addr );
@@ -1162,5 +1162,5 @@
 		header->kind.real.blockSize |= 2;				// mark as zero filled
 		return ret;
-	} // $malloc_zero_fill_set
+	} // malloc_zero_fill_set$
 
 
@@ -1176,5 +1176,5 @@
 
 	// Set allocation size and return previous size.
-	size_t $malloc_size_set( void * addr, size_t size ) {
+	size_t malloc_size_set$( void * addr, size_t size ) {
 	  if ( unlikely( addr == 0p ) ) return 0;			// null allocation has 0 size
 		HeapManager.Storage.Header * header = headerAddr( addr );
@@ -1185,5 +1185,5 @@
 		header->kind.real.size = size;
 		return ret;
-	} // $malloc_size_set
+	} // malloc_size_set$
 
 
Index: libcfa/src/iostream.cfa
===================================================================
--- libcfa/src/iostream.cfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/iostream.cfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 13 13:05:24 2021
-// Update Count     : 1324
+// Last Modified On : Tue Apr 20 19:09:41 2021
+// Update Count     : 1325
 //
 
@@ -38,5 +38,5 @@
 forall( ostype & | ostream( ostype ) ) {
 	ostype & ?|?( ostype & os, bool b ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%s", b ? "true" : "false" );
 		return os;
@@ -48,5 +48,5 @@
 	ostype & ?|?( ostype & os, char c ) {
 		fmt( os, "%c", c );
-		if ( c == '\n' ) $setNL( os, true );
+		if ( c == '\n' ) setNL$( os, true );
 		return sepOff( os );
 	} // ?|?
@@ -56,5 +56,5 @@
 
 	ostype & ?|?( ostype & os, signed char sc ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%hhd", sc );
 		return os;
@@ -65,5 +65,5 @@
 
 	ostype & ?|?( ostype & os, unsigned char usc ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%hhu", usc );
 		return os;
@@ -74,5 +74,5 @@
 
 	ostype & ?|?( ostype & os, short int si ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%hd", si );
 		return os;
@@ -83,5 +83,5 @@
 
 	ostype & ?|?( ostype & os, unsigned short int usi ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%hu", usi );
 		return os;
@@ -92,5 +92,5 @@
 
 	ostype & ?|?( ostype & os, int i ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%d", i );
 		return os;
@@ -101,5 +101,5 @@
 
 	ostype & ?|?( ostype & os, unsigned int ui ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%u", ui );
 		return os;
@@ -110,5 +110,5 @@
 
 	ostype & ?|?( ostype & os, long int li ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%ld", li );
 		return os;
@@ -119,5 +119,5 @@
 
 	ostype & ?|?( ostype & os, unsigned long int uli ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%lu", uli );
 		return os;
@@ -128,5 +128,5 @@
 
 	ostype & ?|?( ostype & os, long long int lli ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%lld", lli );
 		return os;
@@ -137,5 +137,5 @@
 
 	ostype & ?|?( ostype & os, unsigned long long int ulli ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%llu", ulli );
 		return os;
@@ -171,5 +171,5 @@
 
 	ostype & ?|?( ostype & os, int128 llli ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		base10_128( os, llli );
 		return os;
@@ -180,5 +180,5 @@
 
 	ostype & ?|?( ostype & os, unsigned int128 ullli ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		base10_128( os, ullli );
 		return os;
@@ -204,5 +204,5 @@
 
 	ostype & ?|?( ostype & os, float f ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		PrintWithDP( os, "%g", f );
 		return os;
@@ -213,5 +213,5 @@
 
 	ostype & ?|?( ostype & os, double d ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		PrintWithDP( os, "%.*lg", d, DBL_DIG );
 		return os;
@@ -222,5 +222,5 @@
 
 	ostype & ?|?( ostype & os, long double ld ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
 		return os;
@@ -231,5 +231,5 @@
 
 	ostype & ?|?( ostype & os, float _Complex fc ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //		os | crealf( fc ) | nonl;
 		PrintWithDP( os, "%g", crealf( fc ) );
@@ -243,5 +243,5 @@
 
 	ostype & ?|?( ostype & os, double _Complex dc ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //		os | creal( dc ) | nonl;
 		PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
@@ -255,5 +255,5 @@
 
 	ostype & ?|?( ostype & os, long double _Complex ldc ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //		os | creall( ldc ) || nonl;
 		PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
@@ -286,20 +286,20 @@
 		// first character IS NOT spacing or closing punctuation => add left separator
 		unsigned char ch = s[0];						// must make unsigned
-		if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
-			fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+			fmt( os, "%s", sepGetCur$( os ) );
 		} // if
 
 		// if string starts line, must reset to determine open state because separator is off
-		$sepReset( os );								// reset separator
+		sepReset$( os );								// reset separator
 
 		// last character IS spacing or opening punctuation => turn off separator for next item
 		size_t len = strlen( s );
 		ch = s[len - 1];								// must make unsigned
-		if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+		if ( sepPrt$( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
 			sepOn( os );
 		} else {
 			sepOff( os );
 		} // if
-		if ( ch == '\n' ) $setNL( os, true );			// check *AFTER* $sepPrt call above as it resets NL flag
+		if ( ch == '\n' ) setNL$( os, true );			// check *AFTER* sepPrt$ call above as it resets NL flag
 		return write( os, s, len );
 	} // ?|?
@@ -309,5 +309,5 @@
 
 // 	ostype & ?|?( ostype & os, const char16_t * s ) {
-// 		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+// 		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 // 		fmt( os, "%ls", s );
 // 		return os;
@@ -316,5 +316,5 @@
 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 // 	ostype & ?|?( ostype & os, const char32_t * s ) {
-// 		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+// 		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 // 		fmt( os, "%ls", s );
 // 		return os;
@@ -323,5 +323,5 @@
 
 // 	ostype & ?|?( ostype & os, const wchar_t * s ) {
-// 		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+// 		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 // 		fmt( os, "%ls", s );
 // 		return os;
@@ -329,5 +329,5 @@
 
 	ostype & ?|?( ostype & os, const void * p ) {
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 		fmt( os, "%p", p );
 		return os;
@@ -343,6 +343,6 @@
 	void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
 		manip( os );
-		if ( $getPrt( os ) ) ends( os );				// something printed ?
-		$setPrt( os, false );							// turn off
+		if ( getPrt$( os ) ) ends( os );				// something printed ?
+		setPrt$( os, false );							// turn off
 	} // ?|?
 
@@ -357,6 +357,6 @@
 	ostype & nl( ostype & os ) {
 		(ostype &)(os | '\n');
-		$setPrt( os, false );							// turn off
-		$setNL( os, true );
+		setPrt$( os, false );							// turn off
+		setNL$( os, true );
 		flush( os );
 		return sepOff( os );							// prepare for next line
@@ -364,5 +364,5 @@
 
 	ostype & nonl( ostype & os ) {
-		$setPrt( os, false );							// turn off
+		setPrt$( os, false );							// turn off
 		return os;
 	} // nonl
@@ -408,7 +408,7 @@
 	ostype & ?|?( ostype & os, T arg, Params rest ) {
 		(ostype &)(os | arg);							// print first argument
-		$sepSetCur( os, sepGetTuple( os ) );			// switch to tuple separator
+		sepSetCur$( os, sepGetTuple( os ) );			// switch to tuple separator
 		(ostype &)(os | rest);							// print remaining arguments
-		$sepSetCur( os, sepGet( os ) );					// switch to regular separator
+		sepSetCur$( os, sepGet( os ) );					// switch to regular separator
 		return os;
 	} // ?|?
@@ -416,7 +416,7 @@
 		// (ostype &)(?|?( os, arg, rest )); ends( os );
 		(ostype &)(os | arg);							// print first argument
-		$sepSetCur( os, sepGetTuple( os ) );			// switch to tuple separator
+		sepSetCur$( os, sepGetTuple( os ) );			// switch to tuple separator
 		(ostype &)(os | rest);							// print remaining arguments
-		$sepSetCur( os, sepGet( os ) );					// switch to regular separator
+		sepSetCur$( os, sepGet( os ) );					// switch to regular separator
 		ends( os );
 	} // ?|?
@@ -447,5 +447,5 @@
 forall( ostype & | ostream( ostype ) ) { \
 	ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
 \
 		if ( f.base == 'b' || f.base == 'B' ) {			/* bespoke binary format */ \
@@ -691,5 +691,5 @@
 		int bufbeg = 0, i, len; \
 \
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
 		char fmtstr[sizeof(DFMTP) + 8];					/* sizeof includes '\0' */ \
 		if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
@@ -734,5 +734,5 @@
 		} // if
 
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 
 		#define CFMTNP "% * "
@@ -772,5 +772,5 @@
 		} // if
 
-		if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+		if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 
 		#define SFMTNP "% * "
Index: libcfa/src/iostream.hfa
===================================================================
--- libcfa/src/iostream.hfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/iostream.hfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 13 13:05:11 2021
-// Update Count     : 384
+// Last Modified On : Tue Apr 20 19:09:44 2021
+// Update Count     : 385
 //
 
@@ -24,14 +24,14 @@
 trait ostream( ostype & ) {
 	// private
-	bool $sepPrt( ostype & );							// get separator state (on/off)
-	void $sepReset( ostype & );							// set separator state to default state
-	void $sepReset( ostype &, bool );					// set separator and default state
-	const char * $sepGetCur( ostype & );				// get current separator string
-	void $sepSetCur( ostype &, const char [] );			// set current separator string
-	bool $getNL( ostype & );							// check newline
-	void $setNL( ostype &, bool );						// saw newline
-	bool $getANL( ostype & );							// get auto newline (on/off)
-	bool $getPrt( ostype & );							// get fmt called in output cascade
-	void $setPrt( ostype &, bool );						// set fmt called in output cascade
+	bool sepPrt$( ostype & );							// get separator state (on/off)
+	void sepReset$( ostype & );							// set separator state to default state
+	void sepReset$( ostype &, bool );					// set separator and default state
+	const char * sepGetCur$( ostype & );				// get current separator string
+	void sepSetCur$( ostype &, const char [] );			// set current separator string
+	bool getNL$( ostype & );							// check newline
+	void setNL$( ostype &, bool );						// saw newline
+	bool getANL$( ostype & );							// get auto newline (on/off)
+	bool getPrt$( ostype & );							// get fmt called in output cascade
+	void setPrt$( ostype &, bool );						// set fmt called in output cascade
 	// public
 	void sepOn( ostype & );								// turn separator state on
Index: libcfa/src/stdlib.hfa
===================================================================
--- libcfa/src/stdlib.hfa	(revision 59f3f616c737817ce7af766fa1bcf77a79d695d9)
+++ libcfa/src/stdlib.hfa	(revision 6c5d92fac53b3a47e9d4fcd8c136fc98aa0c7c03)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jan 21 22:02:13 2021
-// Update Count     : 574
+// Last Modified On : Tue Apr 20 21:20:03 2021
+// Update Count     : 575
 //
 
@@ -44,5 +44,5 @@
 
 // Macro because of returns
-#define $ARRAY_ALLOC( allocation, alignment, dim ) \
+#define ARRAY_ALLOC$( allocation, alignment, dim ) \
 	if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
 	else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
@@ -57,9 +57,9 @@
 
 	T * aalloc( size_t dim ) {
-		$ARRAY_ALLOC( aalloc, amemalign, dim );
+		ARRAY_ALLOC$( aalloc, amemalign, dim );
 	} // aalloc
 
 	T * calloc( size_t dim ) {
-		$ARRAY_ALLOC( calloc, cmemalign, dim );
+		ARRAY_ALLOC$( calloc, cmemalign, dim );
 	} // calloc
 
@@ -119,6 +119,6 @@
 		S_fill(T) ?`fill( T    a[], size_t nmemb ) 	{ S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
 
-	3. Replace the $alloc_internal function which is outside ttype forall-block with following function:
-		T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
+	3. Replace the alloc_internal$ function which is outside ttype forall-block with following function:
+		T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
 			T * ptr = NULL;
 			size_t size = sizeof(T);
@@ -145,5 +145,5 @@
 
 			return ptr;
-		} // $alloc_internal
+		} // alloc_internal$
 */
 
@@ -175,5 +175,5 @@
 	S_realloc(T) 	?`realloc ( T * a )				{ return (S_realloc(T)){a}; }
 
-	T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
+	T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
 		T * ptr = NULL;
 		size_t size = sizeof(T);
@@ -206,30 +206,30 @@
 
 		return ptr;
-	} // $alloc_internal
-
-	forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
-
-		T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
-	        return $alloc_internal( Resize, (T*)0p, Align, Dim, Fill, rest);
-		}
-
-		T * $alloc_internal( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
-	        return $alloc_internal( (void*)0p, Realloc, Align, Dim, Fill, rest);
-		}
-
-		T * $alloc_internal( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
-	        return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
-		}
-
-		T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
-	        return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
+	} // alloc_internal$
+
+	forall( TT... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
+
+		T * alloc_internal$( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
+	        return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
+		}
+
+		T * alloc_internal$( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
+	        return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest);
+		}
+
+		T * alloc_internal$( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
+	        return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
+		}
+
+		T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
+	        return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
 		}
 
 	    T * alloc( TT all ) {
-	    	return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
+	    	return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
 	    }
 
 	    T * alloc( size_t dim, TT all ) {
-	    	return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
+	    	return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
 	    }