Index: src/libcfa/clock
===================================================================
--- src/libcfa/clock	(revision 4c3ee8d83b18fa8870e0a924b814efd4ec1730fa)
+++ src/libcfa/clock	(revision bbe1a87944804b0f3c9e486087ca6af21340e747)
@@ -10,6 +10,6 @@
 // Created On       : Thu Apr 12 14:36:06 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jun 26 14:11:44 2018
-// Update Count     : 6
+// Last Modified On : Mon Jul  2 21:40:01 2018
+// Update Count     : 7
 // 
 
@@ -34,58 +34,60 @@
 };
 
-static inline void resetClock( Clock & clk ) with( clk ) {
-	clocktype = CLOCK_REALTIME_COARSE;
-} // Clock::resetClock
+static inline {
+	void resetClock( Clock & clk ) with( clk ) {
+		clocktype = CLOCK_REALTIME_COARSE;
+	} // Clock::resetClock
 
-static inline void resetClock( Clock & clk, Duration adj ) with( clk ) {
-	clocktype = -1;
-	offset = adj + __timezone`s;							// timezone (global) is (UTC - local time) in seconds
-} // resetClock
+	void resetClock( Clock & clk, Duration adj ) with( clk ) {
+		clocktype = -1;
+		offset = adj + __timezone`s;					// timezone (global) is (UTC - local time) in seconds
+	} // resetClock
 
-static inline void ?{}( Clock & clk ) { resetClock( clk ); }
-static inline void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
+	void ?{}( Clock & clk ) { resetClock( clk ); }
+	void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
 
-static inline Duration getResNsec() {
-	struct timespec res;
-	clock_getres( CLOCK_REALTIME, &res );
-	return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
-} // getRes
+	Duration getResNsec() {
+		struct timespec res;
+		clock_getres( CLOCK_REALTIME, &res );
+		return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
+	} // getRes
 
-static inline Duration getRes() {
-	struct timespec res;
-	clock_getres( CLOCK_REALTIME_COARSE, &res );
-	return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
-} // getRes
+	Duration getRes() {
+		struct timespec res;
+		clock_getres( CLOCK_REALTIME_COARSE, &res );
+		return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
+	} // getRes
 
-static inline Time getTimeNsec() {						// with nanoseconds
-	timespec curr;
-	clock_gettime( CLOCK_REALTIME, &curr );
-	return (Time){ curr };
-} // getTime
+	Time getTimeNsec() {								// with nanoseconds
+		timespec curr;
+		clock_gettime( CLOCK_REALTIME, &curr );
+		return (Time){ curr };
+	} // getTime
 
-static inline Time getTime() {							// without nanoseconds
-	timespec curr;
-	clock_gettime( CLOCK_REALTIME_COARSE, &curr );
-	curr.tv_nsec = 0;
-	return (Time){ curr };
-} // getTime
+	Time getTime() {									// without nanoseconds
+		timespec curr;
+		clock_gettime( CLOCK_REALTIME_COARSE, &curr );
+		curr.tv_nsec = 0;
+		return (Time){ curr };
+	} // getTime
 
-static inline Time getTime( Clock & clk ) with( clk ) {
-	return getTime() + offset;
-} // getTime
+	Time getTime( Clock & clk ) with( clk ) {
+		return getTime() + offset;
+	} // getTime
 
-static inline Time ?()( Clock & clk ) with( clk ) {		// alternative syntax
-	return getTime() + offset;
-} // getTime
+	Time ?()( Clock & clk ) with( clk ) {				// alternative syntax
+		return getTime() + offset;
+	} // getTime
 
-static inline timeval getTime( Clock & clk ) {
-	return (timeval){ clk() };
-} // getTime
+	timeval getTime( Clock & clk ) {
+		return (timeval){ clk() };
+	} // getTime
 
-static inline tm getTime( Clock & clk ) with( clk ) {
-	tm ret;
-	localtime_r( getTime( clk ).tv_sec, &ret );
-	return ret;
-} // getTime
+	tm getTime( Clock & clk ) with( clk ) {
+		tm ret;
+		localtime_r( getTime( clk ).tv_sec, &ret );
+		return ret;
+	} // getTime
+} // distribution
 
 // Local Variables: //
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision 4c3ee8d83b18fa8870e0a924b814efd4ec1730fa)
+++ src/libcfa/stdlib	(revision bbe1a87944804b0f3c9e486087ca6af21340e747)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun  2 08:46:35 2018
-// Update Count     : 306
+// Last Modified On : Tue Jul  3 08:17:28 2018
+// Update Count     : 324
 //
 
@@ -264,25 +264,32 @@
 //---------------------------------------
 
-extern "C" { void srandom( unsigned int seed ); }		// override C version
-char random( void );
-char random( char u );
-char random( char l, char u );
-int random( void );
-int random( int u );
-int random( int l, int u );
-unsigned int random( void );
-unsigned int random( unsigned int u );
-unsigned int random( unsigned int l, unsigned int u );
-extern "C" { long int random( void ); }					// override C version
-long int random( long int u );
-long int random( long int l, long int u );
-unsigned long int random( void );
-unsigned long int random( unsigned long int u );
-unsigned long int random( unsigned long int l, unsigned long int u );
-float random( void );
-double random( void );
-float _Complex random( void );
-double _Complex random( void );
-long double _Complex random( void );
+extern "C" {											// override C version
+	void srandom( unsigned int seed );
+	long int random( void );
+} // extern "C"
+
+static inline {
+	long int random( long int l, long int u ) { if ( u < l ) [u, l] = [l, u]; return lrand48() % (u - l) + l; } // [l,u)
+	long int random( long int u ) { if ( u < 0 ) return random( u, 0 ); else return random( 0, u ); } // [0,u)
+	unsigned long int random( void ) { return lrand48(); }
+	unsigned long int random( unsigned long int l, unsigned long int u ) { if ( u < l ) [u, l] = [l, u]; return lrand48() % (u - l) + l; } // [l,u)
+	unsigned long int random( unsigned long int u ) { return lrand48() % u; } // [0,u)
+
+	char random( void ) { return (unsigned long int)random(); }
+	char random( char u ) { return random( (unsigned long int)u ); } // [0,u)
+	char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u)
+	int random( void ) { return (long int)random(); }
+	int random( int u ) { return random( (long int)u ); } // [0,u]
+	int random( int l, int u ) { return random( (long int)l, (long int)u ); } // [l,u)
+	unsigned int random( void ) { return (unsigned long int)random(); }
+	unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); } // [0,u]
+	unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); } // [l,u)
+} // distribution
+
+float random( void );									// [0.0, 1.0)
+double random( void );									// [0.0, 1.0)
+float _Complex random( void );							// [0.0, 1.0)+[0.0, 1.0)i
+double _Complex random( void );							// [0.0, 1.0)+[0.0, 1.0)i
+long double _Complex random( void );					// [0.0, 1.0)+[0.0, 1.0)i
 
 //---------------------------------------
Index: src/libcfa/stdlib.c
===================================================================
--- src/libcfa/stdlib.c	(revision 4c3ee8d83b18fa8870e0a924b814efd4ec1730fa)
+++ src/libcfa/stdlib.c	(revision bbe1a87944804b0f3c9e486087ca6af21340e747)
@@ -10,6 +10,6 @@
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jun  2 06:15:05 2018
-// Update Count     : 448
+// Last Modified On : Tue Jul  3 08:17:30 2018
+// Update Count     : 457
 //
 
@@ -249,20 +249,9 @@
 //---------------------------------------
 
-extern "C" { void srandom( unsigned int seed ) { srand48( (long int)seed ); } } // override C version
-char random( void ) { return (unsigned long int)random(); }
-char random( char u ) { return random( (unsigned long int)u ); }
-char random( char l, char u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
-int random( void ) { return (long int)random(); }
-int random( int u ) { return random( (long int)u ); }
-int random( int l, int u ) { return random( (long int)l, (long int)u ); }
-unsigned int random( void ) { return (unsigned long int)random(); }
-unsigned int random( unsigned int u ) { return random( (unsigned long int)u ); }
-unsigned int random( unsigned int l, unsigned int u ) { return random( (unsigned long int)l, (unsigned long int)u ); }
-extern "C" { long int random( void ) { return mrand48(); } } // override C version
-long int random( long int u ) { if ( u < 0 ) return random( u, 0 ); else return random( 0, u ); }
-long int random( long int l, long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
-unsigned long int random( void ) { return lrand48(); }
-unsigned long int random( unsigned long int u ) { return lrand48() % u; }
-unsigned long int random( unsigned long int l, unsigned long int u ) { assert( l < u ); return lrand48() % (u - l) + l; }
+extern "C" {											// override C version
+	void srandom( unsigned int seed ) { srand48( (long int)seed ); }
+	long int random( void ) { return mrand48(); }
+} // extern "C"
+
 float random( void ) { return (float)drand48(); }		// cast otherwise float uses lrand48
 double random( void ) { return drand48(); }
Index: src/libcfa/time
===================================================================
--- src/libcfa/time	(revision 4c3ee8d83b18fa8870e0a924b814efd4ec1730fa)
+++ src/libcfa/time	(revision bbe1a87944804b0f3c9e486087ca6af21340e747)
@@ -10,6 +10,6 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Apr 14 17:48:23 2018
-// Update Count     : 636
+// Last Modified On : Mon Jul  2 21:28:38 2018
+// Update Count     : 641
 //
 
@@ -27,143 +27,150 @@
 enum { TIMEGRAN = 1_000_000_000LL };					// nanosecond granularity, except for timeval
 
-
 //######################### Duration #########################
 
-static inline Duration ?=?( Duration & dur, zero_t ) { return dur{ 0 }; }
-
-static inline Duration +?( Duration rhs ) with( rhs ) {	return (Duration)@{ +tv }; }
-static inline Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
-static inline Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
-
-static inline Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
-static inline Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
-static inline Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
-
-static inline Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
-static inline Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
-static inline Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
-
-static inline int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
-static inline Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
-static inline Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
-static inline double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
-
-static inline Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
-static inline Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
-
-static inline _Bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
-static inline _Bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
-static inline _Bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
-static inline _Bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
-static inline _Bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
-static inline _Bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
-
-static inline _Bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
-static inline _Bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
-static inline _Bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
-static inline _Bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
-static inline _Bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
-static inline _Bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
-
-static inline Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
-
-static inline Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
-static inline Duration ?`us( int64_t usec ) { return (Duration)@{ usec * (TIMEGRAN / 1_000_000LL) }; }
-static inline Duration ?`ms( int64_t msec ) { return (Duration)@{ msec * (TIMEGRAN / 1_000LL) }; }
-static inline Duration ?`s( int64_t sec ) { return (Duration)@{ sec * TIMEGRAN }; }
-static inline Duration ?`s( double sec ) { return (Duration)@{ sec * TIMEGRAN }; }
-static inline Duration ?`m( int64_t min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
-static inline Duration ?`m( double min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
-static inline Duration ?`h( int64_t hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`h( double hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`d( int64_t days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`d( double days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`w( int64_t weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
-static inline Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
-
-static inline int64_t ?`ns( Duration dur ) { return dur.tv; }
-static inline int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
-static inline int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
-static inline int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
-static inline int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
-static inline int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
-static inline int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
-static inline int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
-
-static inline Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
-static inline Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
-
+static inline {
+	Duration ?=?( Duration & dur, zero_t ) { return dur{ 0 }; }
+
+	Duration +?( Duration rhs ) with( rhs ) {	return (Duration)@{ +tv }; }
+	Duration ?+?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv + rhs.tv }; }
+	Duration ?+=?( Duration & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
+
+	Duration -?( Duration rhs ) with( rhs ) { return (Duration)@{ -tv }; }
+	Duration ?-?( Duration & lhs, Duration rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+	Duration ?-=?( Duration & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
+
+	Duration ?*?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv * rhs }; }
+	Duration ?*?( int64_t lhs, Duration rhs ) { return (Duration)@{ lhs * rhs.tv }; }
+	Duration ?*=?( Duration & lhs, int64_t rhs ) { lhs = lhs * rhs; return lhs; }
+
+	int64_t ?/?( Duration lhs, Duration rhs ) { return lhs.tv / rhs.tv; }
+	Duration ?/?( Duration lhs, int64_t rhs ) { return (Duration)@{ lhs.tv / rhs }; }
+	Duration ?/=?( Duration & lhs, int64_t rhs ) { lhs = lhs / rhs; return lhs; }
+	double div( Duration lhs, Duration rhs ) { return (double)lhs.tv / (double)rhs.tv; }
+
+	Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tv % rhs.tv }; }
+	Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
+
+	_Bool ?==?( Duration lhs, Duration rhs ) { return lhs.tv == rhs.tv; }
+	_Bool ?!=?( Duration lhs, Duration rhs ) { return lhs.tv != rhs.tv; }
+	_Bool ?<? ( Duration lhs, Duration rhs ) { return lhs.tv <  rhs.tv; }
+	_Bool ?<=?( Duration lhs, Duration rhs ) { return lhs.tv <= rhs.tv; }
+	_Bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tv >  rhs.tv; }
+	_Bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tv >= rhs.tv; }
+
+	_Bool ?==?( Duration lhs, zero_t ) { return lhs.tv == 0; }
+	_Bool ?!=?( Duration lhs, zero_t ) { return lhs.tv != 0; }
+	_Bool ?<? ( Duration lhs, zero_t ) { return lhs.tv <  0; }
+	_Bool ?<=?( Duration lhs, zero_t ) { return lhs.tv <= 0; }
+	_Bool ?>? ( Duration lhs, zero_t ) { return lhs.tv >  0; }
+	_Bool ?>=?( Duration lhs, zero_t ) { return lhs.tv >= 0; }
+
+	Duration abs( Duration rhs ) { return rhs.tv >= 0 ? rhs : -rhs; }
+
+	Duration ?`ns( int64_t nsec ) { return (Duration)@{ nsec }; }
+	Duration ?`us( int64_t usec ) { return (Duration)@{ usec * (TIMEGRAN / 1_000_000LL) }; }
+	Duration ?`ms( int64_t msec ) { return (Duration)@{ msec * (TIMEGRAN / 1_000LL) }; }
+	Duration ?`s( int64_t sec ) { return (Duration)@{ sec * TIMEGRAN }; }
+	Duration ?`s( double sec ) { return (Duration)@{ sec * TIMEGRAN }; }
+	Duration ?`m( int64_t min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
+	Duration ?`m( double min ) { return (Duration)@{ min * (60LL * TIMEGRAN) }; }
+	Duration ?`h( int64_t hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
+	Duration ?`h( double hours ) { return (Duration)@{ hours * (60LL * 60LL * TIMEGRAN) }; }
+	Duration ?`d( int64_t days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
+	Duration ?`d( double days ) { return (Duration)@{ days * (24LL * 60LL * 60LL * TIMEGRAN) }; }
+	Duration ?`w( int64_t weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
+	Duration ?`w( double weeks ) { return (Duration)@{ weeks * (7LL * 24LL * 60LL * 60LL * TIMEGRAN) }; }
+
+	int64_t ?`ns( Duration dur ) { return dur.tv; }
+	int64_t ?`us( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000_000LL); }
+	int64_t ?`ms( Duration dur ) { return dur.tv / (TIMEGRAN / 1_000LL); }
+	int64_t ?`s( Duration dur ) { return dur.tv / TIMEGRAN; }
+	int64_t ?`m( Duration dur ) { return dur.tv / (60LL * TIMEGRAN); }
+	int64_t ?`h( Duration dur ) { return dur.tv / (60LL * 60LL * TIMEGRAN); }
+	int64_t ?`d( Duration dur ) { return dur.tv / (24LL * 60LL * 60LL * TIMEGRAN); }
+	int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
+
+	Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
+	Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
+} // distribution
 
 //######################### C timeval #########################
 
-static inline void ?{}( timeval & t ) {}
-static inline void ?{}( timeval & t, time_t sec, suseconds_t usec ) { t.tv_sec = sec; t.tv_usec = usec; }
-static inline void ?{}( timeval & t, time_t sec ) { t{ sec, 0 }; }
-static inline void ?{}( timeval & t, zero_t ) { t{ 0, 0 }; }
-static inline timeval ?=?( timeval & t, zero_t ) { return t{ 0 }; }
-static inline timeval ?+?( timeval & lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_usec + rhs.tv_usec }; }
-static inline timeval ?-?( timeval & lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_usec - rhs.tv_usec }; }
-static inline _Bool ?==?( timeval lhs, timeval rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_usec == rhs.tv_usec; }
-static inline _Bool ?!=?( timeval lhs, timeval rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_usec != rhs.tv_usec; }
-
+static inline {
+	void ?{}( timeval & t ) {}
+	void ?{}( timeval & t, time_t sec, suseconds_t usec ) { t.tv_sec = sec; t.tv_usec = usec; }
+	void ?{}( timeval & t, time_t sec ) { t{ sec, 0 }; }
+	void ?{}( timeval & t, zero_t ) { t{ 0, 0 }; }
+
+	timeval ?=?( timeval & t, zero_t ) { return t{ 0 }; }
+	timeval ?+?( timeval & lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_usec + rhs.tv_usec }; }
+	timeval ?-?( timeval & lhs, timeval rhs ) { return (timeval)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_usec - rhs.tv_usec }; }
+	_Bool ?==?( timeval lhs, timeval rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_usec == rhs.tv_usec; }
+	_Bool ?!=?( timeval lhs, timeval rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_usec != rhs.tv_usec; }
+} // distribution
 
 //######################### C timespec #########################
 
-static inline void ?{}( timespec & t ) {}
-static inline void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec ) { t.tv_sec = sec; t.tv_nsec = nsec; }
-static inline void ?{}( timespec & t, time_t sec ) { t{ sec, 0}; }
-static inline void ?{}( timespec & t, zero_t ) { t{ 0, 0 }; }
-static inline timespec ?=?( timespec & t, zero_t ) { return t{ 0 }; }
-static inline timespec ?+?( timespec & lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_nsec + rhs.tv_nsec }; }
-static inline timespec ?-?( timespec & lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_nsec - rhs.tv_nsec }; }
-static inline _Bool ?==?( timespec lhs, timespec rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec; }
-static inline _Bool ?!=?( timespec lhs, timespec rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_nsec != rhs.tv_nsec; }
-
+static inline {
+	void ?{}( timespec & t ) {}
+	void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec ) { t.tv_sec = sec; t.tv_nsec = nsec; }
+	void ?{}( timespec & t, time_t sec ) { t{ sec, 0}; }
+	void ?{}( timespec & t, zero_t ) { t{ 0, 0 }; }
+
+	timespec ?=?( timespec & t, zero_t ) { return t{ 0 }; }
+	timespec ?+?( timespec & lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec + rhs.tv_sec, lhs.tv_nsec + rhs.tv_nsec }; }
+	timespec ?-?( timespec & lhs, timespec rhs ) { return (timespec)@{ lhs.tv_sec - rhs.tv_sec, lhs.tv_nsec - rhs.tv_nsec }; }
+	_Bool ?==?( timespec lhs, timespec rhs ) { return lhs.tv_sec == rhs.tv_sec && lhs.tv_nsec == rhs.tv_nsec; }
+	_Bool ?!=?( timespec lhs, timespec rhs ) { return lhs.tv_sec != rhs.tv_sec || lhs.tv_nsec != rhs.tv_nsec; }
+} // distribution
 
 //######################### C itimerval #########################
 
-static inline void ?{}( itimerval & itv, Duration alarm ) with( itv ) {
-	// itimerval contains durations but but uses time data-structure timeval.
-	it_value{ alarm`s, (alarm % 1`s)`us };				// seconds, microseconds
-	it_interval{ 0 };									// 0 seconds, 0 microseconds
-} // itimerval
-
-static inline void ?{}( itimerval & itv, Duration alarm, Duration interval ) with( itv ) {
-	// itimerval contains durations but but uses time data-structure timeval.
-	it_value{ alarm`s, (alarm % 1`s)`us };				// seconds, microseconds
-	it_interval{ interval`s, interval`us };				// seconds, microseconds
-} // itimerval
-
+static inline {
+	void ?{}( itimerval & itv, Duration alarm ) with( itv ) {
+		// itimerval contains durations but but uses time data-structure timeval.
+		it_value{ alarm`s, (alarm % 1`s)`us };			// seconds, microseconds
+		it_interval{ 0 };								// 0 seconds, 0 microseconds
+	} // itimerval
+
+	void ?{}( itimerval & itv, Duration alarm, Duration interval ) with( itv ) {
+		// itimerval contains durations but but uses time data-structure timeval.
+		it_value{ alarm`s, (alarm % 1`s)`us };			// seconds, microseconds
+		it_interval{ interval`s, interval`us };			// seconds, microseconds
+	} // itimerval
+} // distribution
 
 //######################### Time #########################
 
 void ?{}( Time & time, int year, int month = 0, int day = 0, int hour = 0, int min = 0, int sec = 0, int nsec = 0 );
-static inline Time ?=?( Time & time, zero_t ) { return time{ 0 }; }
-
-static inline void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
-static inline Time ?=?( Time & time, timeval t ) with( time ) {
-	tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
-	return time;
-} // ?=?
-
-static inline void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
-static inline Time ?=?( Time & time, timespec t ) with( time ) {
-	tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
-	return time;
-} // ?=?
-
-static inline Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
-static inline Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
-static inline Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
-
-static inline Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
-static inline Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
-static inline Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
-static inline _Bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
-static inline _Bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
-static inline _Bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
-static inline _Bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
-static inline _Bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
-static inline _Bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
+static inline {
+	Time ?=?( Time & time, zero_t ) { return time{ 0 }; }
+
+	void ?{}( Time & time, timeval t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+	Time ?=?( Time & time, timeval t ) with( time ) {
+		tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+		return time;
+	} // ?=?
+
+	void ?{}( Time & time, timespec t ) with( time ) { tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+	Time ?=?( Time & time, timespec t ) with( time ) {
+		tv = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+		return time;
+	} // ?=?
+
+	Time ?+?( Time & lhs, Duration rhs ) { return (Time)@{ lhs.tv + rhs.tv }; }
+	Time ?+?( Duration lhs, Time rhs ) { return rhs + lhs; }
+	Time ?+=?( Time & lhs, Duration rhs ) { lhs = lhs + rhs; return lhs; }
+
+	Duration ?-?( Time lhs, Time rhs ) { return (Duration)@{ lhs.tv - rhs.tv }; }
+	Time ?-?( Time lhs, Duration rhs ) { return (Time)@{ lhs.tv - rhs.tv }; }
+	Time ?-=?( Time & lhs, Duration rhs ) { lhs = lhs - rhs; return lhs; }
+	_Bool ?==?( Time lhs, Time rhs ) { return lhs.tv == rhs.tv; }
+	_Bool ?!=?( Time lhs, Time rhs ) { return lhs.tv != rhs.tv; }
+	_Bool ?<?( Time lhs, Time rhs ) { return lhs.tv < rhs.tv; }
+	_Bool ?<=?( Time lhs, Time rhs ) { return lhs.tv <= rhs.tv; }
+	_Bool ?>?( Time lhs, Time rhs ) { return lhs.tv > rhs.tv; }
+	_Bool ?>=?( Time lhs, Time rhs ) { return lhs.tv >= rhs.tv; }
+} // distribution
 
 char * yy_mm_dd( Time time, char * buf );