Index: libcfa/src/iostream.cfa
===================================================================
--- libcfa/src/iostream.cfa	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ libcfa/src/iostream.cfa	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -10,6 +10,6 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Oct 13 10:53:09 2024
-// Update Count     : 2041
+// Last Modified On : Wed Jan 22 07:31:19 2025
+// Update Count     : 2079
 //
 
@@ -777,10 +777,11 @@
 forall( istype & | basic_istream( istype ) ) {
 	istype & ?|?( istype & is, bool & b ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		int len = -1;									// len not set if no match
-		// remove optional leading whitespace at start of strings.
-		fmt( is, " " FALSE "%n", &len );				// try false
+		fmt( is, " " );									// remove leading whitespace
+		fmt( is, FALSE "%n", &len );					// try false, returns 0
 		if ( len != sizeof( FALSE ) - 1 ) {				// -1 removes null terminate
-			fmt( is, " " TRUE "%n", &len );				// try true
+			if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
+			fmt( is, " " );								// remove leading whitespace
+			fmt( is, TRUE "%n", &len );					// try true, returns 0
 			if ( len != sizeof( TRUE ) - 1 ) throwResume ExceptionInst( missing_data );
 			b = true;
@@ -792,8 +793,7 @@
 
 	istype & ?|?( istype & is, char & c ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		char temp;
 		for () {
-			int args = fmt( is, "%c", &temp );
+			int args = fmt( is, "%c", &temp );			// can be called with EOF on
 			if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 			assert( args == 1 );						// if not EOF => a single character must be read
@@ -805,70 +805,70 @@
 
 	istype & ?|?( istype & is, signed char & sc ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		int args = fmt( is, "%hhi", &sc );				// can be multiple characters (100)
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, unsigned char & usc ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		int args = fmt( is, "%hhi", &usc );				// can be multiple characters (-100)
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, short int & si ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%hi", &si );
+		int args = fmt( is, "%hi", &si );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, unsigned short int & usi ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%hi", &usi );
+		int args = fmt( is, "%hi", &usi );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, int & i ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%i", &i );
+		int args = fmt( is, "%i", &i );					// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, unsigned int & ui ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%i", &ui );
+		int args = fmt( is, "%i", &ui );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, long int & li ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%li", &li );
+		int args = fmt( is, "%li", &li );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, unsigned long int & ulli ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%li", &ulli );
+		int args = fmt( is, "%li", &ulli );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, long long int & lli ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%lli", &lli );
+		int args = fmt( is, "%lli", &lli );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, unsigned long long int & ulli ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%lli", &ulli );
+		int args = fmt( is, "%lli", &ulli );			// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
@@ -897,29 +897,29 @@
 
 	istype & ?|?( istype & is, float & f ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%f", &f );
+		int args = fmt( is, "%f", &f );					// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, double & d ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%lf", &d );
+		int args = fmt( is, "%lf", &d );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, long double & ld ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
-		int args = fmt( is, "%Lf", &ld );
+		int args = fmt( is, "%Lf", &ld );				// can be called with EOF on
 		if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
 
 	istype & ?|?( istype & is, float _Complex & fc ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		float re, im;
-		int args = fmt( is, "%f%fi", &re, &im );
+		int args = fmt( is, "%f%fi", &re, &im );		// can be called with EOF on
 		if ( ! eof( is ) && args != 2 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 2 ) throwResume ExceptionInst( end_of_file );
 		fc = re + im * _Complex_I;
 		return is;
@@ -927,8 +927,8 @@
 
 	istype & ?|?( istype & is, double _Complex & dc ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		double re, im;
-		int args = fmt( is, "%lf%lfi", &re, &im );
+		int args = fmt( is, "%lf%lfi", &re, &im );		// can be called with EOF on
 		if ( ! eof( is ) && args != 2 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 2 ) throwResume ExceptionInst( end_of_file );
 		dc = re + im * _Complex_I;
 		return is;
@@ -936,8 +936,8 @@
 
 	istype & ?|?( istype & is, long double _Complex & ldc ) {
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		long double re, im;
-		int args = fmt( is, "%Lf%Lfi", &re, &im );
+		int args = fmt( is, "%Lf%Lfi", &re, &im );		// can be called with EOF on
 		if ( ! eof( is ) && args != 2 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && args != 2 ) throwResume ExceptionInst( end_of_file );
 		ldc = re + im * _Complex_I;
 		return is;
@@ -945,5 +945,4 @@
 
 	istype & ?|?( istype & is, const char fmt[] ) {		// match text
-		if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 		size_t len = strlen( fmt );
 		char fmtstr[len + 16];
@@ -951,7 +950,8 @@
 		strcpy( &fmtstr[len], "%n" );
 		len = -1;
-		// scanf cursor does not move if no match
-		fmt( is, fmtstr, &len );
-		if ( len == -1 ) throwResume ExceptionInst( missing_data );
+		// scanf cursor does not move if no match, so eof cannot be detected.
+		fmt( is, fmtstr, &len );						// can be called with EOF on
+		if ( ! eof( is ) && len == -1 ) throwResume ExceptionInst( missing_data );
+		if ( eof( is ) && len == -1 ) throwResume ExceptionInst( end_of_file );
 		return is;
 	} // ?|?
@@ -999,5 +999,5 @@
 			char ch;
 			for ( f.wd ) {								// skip N characters
-				int args = fmt( is, "%c", &ch );
+				int args = fmt( is, "%c", &ch );		// can be called with EOF on
 				if ( ! eof( is ) && args != 1 ) throwResume ExceptionInst( missing_data );
 			} // for
@@ -1204,17 +1204,13 @@
 forall( istype & | istream( istype ), E | CfaEnum( E ) | Serial( E ) )
 istype & ?|?( istype & is, E & e ) {
-//	fprintf( stderr, "here0\n" );
-	if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
+//	if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 
 	// Match longest input enumerator string to enumerator labels, where enumerator names are unique.
 
 	int N = countof( E ), lnths[N], fred = 0;
-//	printf( "N %d\n", N );
 	int r = 0;
-	// for ( s; E : r; 0~@ ) {
 	for ( s; E ) {										// scan string rows gathering lengths
 		lnths[r] = strlen( label( s ) );
 		if ( lnths[r] > fred ) fred = lnths[r];
-//		fprintf( stderr, "%s %d %d\n", label( s ), lnths[r], fred );
 		r += 1;
 	} // for
@@ -1223,28 +1219,21 @@
 	char ch, curr = '\0', prev = '\0';
 
-	fmt( is, " " );										// skip optional whitespace
+	fmt( is, " " );										// remove leading whitespace
 	if ( eof( is ) ) throwResume ExceptionInst( end_of_file );
 
 	for ( c; fred ) {									// scan columns of the label matix (some columns missing)
 		int args = fmt( is, "%c", &ch );				// read character
-//		fprintf( stderr, "fmt args: %d eof: %d\n", args, eof(is) );
 	  if ( eof( is ) ) {
-//			fprintf( stderr, "Eof1\n" );
 			if ( c == 0 ) return is;					// no characters read ?
 			clear( is );								// => read something => reset EOF => detect again on next read
-//			fprintf( stderr, "Eof2\n" );
 			break;
 		} // if
 	  if ( args != 1 ) throwResume ExceptionInst( missing_data ); // may be unnecessary since reading single character
 
-//		printf( "read '%c'\n", ch );
 		for ( r; N ) {									// scan enumeration strings for matching character in current column
-//			printf( "%d %d %d\n", c, r, lnths[r] );
 			if ( c < lnths[r] ) {						// string long enough for this column check ?
 				char match = label( fromInt( r ) )[c];	// optimization
-//				printf( "%c '%c'\n", match, ch );
 				// Stop on first match, could be other matches.
 				if ( (match == ch) && (c == 0 || curr == label( fromInt( r ) )[c - 1]) ) {
-//					printf( "match %d %d %d '%c' '%c' '%c' '%c' 'c'\n", c, r, lnths[r], match, ch, prev, label( fromInt( r ) )[c - 1] );
 					mcol = c;							// matching column
 					prev = curr;						// last matching character
@@ -1254,12 +1243,8 @@
 			} // if
 		} else {
-//			fprintf( stderr, "finished mcol: %d ch: '%c' curr: '%c' prev: '%c'\n", mcol, ch, curr, prev );
 			ungetc( ch, is );							// push back last unmatching character
 			if ( mcol == -1 ) throwResume ExceptionInst( missing_data ); // no matching character in first column
 			break;
 		} // for
-//		printf( "\n" );
-//	} else {
-//		fprintf( stderr, "finished2 %d\n", mcol );
  	} // for
 
@@ -1267,5 +1252,4 @@
 		if ( mcol == lnths[c] - 1 ) {
 			char match = label( fromInt( c ) )[mcol];	// optimization
-//			printf( "finished1 mcol: %d c: %d lnth: %d match: '%c' curr: '%c' prev: '%c'\n", mcol, c, lnths[c], match, curr, prev );
 			if ( (match == curr) && (mcol == 0 || prev == label( fromInt( c ) )[mcol - 1]) ) {
 				e = fromInt( c );
@@ -1274,5 +1258,4 @@
 		} // if
 	} else {
-//		fprintf( stderr, "finished3 %d\n", mcol );
 		throwResume ExceptionInst( missing_data );		// no match in this column
 	} // for
Index: src/AST/Expr.cpp
===================================================================
--- src/AST/Expr.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Expr.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -283,16 +283,13 @@
 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
 
-// --- CountExpr
-
-CountExpr::CountExpr( const CodeLocation & loc, const Expr * e )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(e), type( nullptr ) {}
-
-CountExpr::CountExpr( const CodeLocation & loc, const Type * t )
-: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), expr(nullptr), type( t ) {}
-
 // --- AlignofExpr
 
 AlignofExpr::AlignofExpr( const CodeLocation & loc, const Type * t )
 : Expr( loc, new BasicType{ BasicKind::LongUnsignedInt } ), type( t ) {}
+
+// --- CountofExpr
+
+CountofExpr::CountofExpr( const CodeLocation & loc, const Type * t )
+: Expr( loc, new BasicType( BasicKind::LongUnsignedInt) ), type( t ) {}
 
 // --- OffsetofExpr
Index: src/AST/Expr.hpp
===================================================================
--- src/AST/Expr.hpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Expr.hpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -490,18 +490,4 @@
 };
 
-class CountExpr final : public Expr {
-public:
-	ptr<Expr> expr;
-	ptr<Type> type;
-
-	CountExpr( const CodeLocation & loc, const Expr * t );
-	CountExpr( const CodeLocation & loc, const Type * t );
-
-	const Expr * accept( Visitor & v )const override { return v.visit( this ); }
-private:
-	CountExpr * clone() const override { return new CountExpr( *this ); }
-	MUTATE_FRIEND
-};
-
 /// alignof expression, e.g. `alignof(int)`, `alignof 3+4`
 class AlignofExpr final : public Expr {
@@ -514,4 +500,17 @@
 private:
 	AlignofExpr * clone() const override { return new AlignofExpr{ *this }; }
+	MUTATE_FRIEND
+};
+
+/// countof expression, e.g. `countof(AnEnum)`, `countof pred(Head)`
+class CountofExpr final : public Expr {
+public:
+	ptr<Type> type;
+
+	CountofExpr( const CodeLocation & loc, const Type * t );
+
+	const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+	CountofExpr * clone() const override { return new CountofExpr( *this ); }
 	MUTATE_FRIEND
 };
Index: src/AST/Fwd.hpp
===================================================================
--- src/AST/Fwd.hpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Fwd.hpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -86,6 +86,6 @@
 class ConstantExpr;
 class SizeofExpr;
-class CountExpr;
 class AlignofExpr;
+class CountofExpr;
 class UntypedOffsetofExpr;
 class OffsetofExpr;
Index: src/AST/Pass.hpp
===================================================================
--- src/AST/Pass.hpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Pass.hpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -173,6 +173,6 @@
 	const ast::Expr *             visit( const ast::ConstantExpr         * ) override final;
 	const ast::Expr *             visit( const ast::SizeofExpr           * ) override final;
-	const ast::Expr *             visit( const ast::CountExpr            * ) override final;
 	const ast::Expr *             visit( const ast::AlignofExpr          * ) override final;
+	const ast::Expr *             visit( const ast::CountofExpr          * ) override final;
 	const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) override final;
 	const ast::Expr *             visit( const ast::OffsetofExpr         * ) override final;
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Pass.impl.hpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -1350,23 +1350,4 @@
 
 //--------------------------------------------------------------------------
-// CountExpr
-template< typename core_t >
-const ast::Expr * ast::Pass< core_t >::visit( const ast::CountExpr * node ) {
-	VISIT_START( node );
-	if ( __visit_children() ) {
-		{
-			guard_symtab guard { *this };
-			maybe_accept( node, &CountExpr::result );
-		}
-		if ( node->type ) {
-			maybe_accept( node, &CountExpr::type );
-		} else {
-			maybe_accept( node, &CountExpr::expr );
-		}
-	}
-	VISIT_END( Expr, node );
-}
-
-//--------------------------------------------------------------------------
 // AlignofExpr
 template< typename core_t >
@@ -1380,4 +1361,21 @@
 		}
 		maybe_accept( node, &AlignofExpr::type );
+	}
+
+	VISIT_END( Expr, node );
+}
+
+//--------------------------------------------------------------------------
+// CountofExpr
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CountofExpr * node ) {
+	VISIT_START( node );
+
+	if ( __visit_children() ) {
+		{
+			guard_symtab guard { *this };
+			maybe_accept( node, &CountofExpr::result );
+		}
+		maybe_accept( node, &CountofExpr::type );
 	}
 
Index: src/AST/Print.cpp
===================================================================
--- src/AST/Print.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Print.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -1207,9 +1207,8 @@
 	}
 
-	virtual const ast::Expr * visit( const ast::CountExpr * node ) override final {
+	virtual const ast::Expr * visit( const ast::CountofExpr * node ) override final {
 		os << "Count Expression on: ";
 		++indent;
-		if ( node->type ) node->type->accept( *this );
-		else safe_print( node->expr );
+		safe_print( node->type );
 		--indent;
 		postprint( node );
Index: src/AST/Visitor.hpp
===================================================================
--- src/AST/Visitor.hpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/AST/Visitor.hpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -76,6 +76,6 @@
     virtual const ast::Expr *             visit( const ast::ConstantExpr         * ) = 0;
     virtual const ast::Expr *             visit( const ast::SizeofExpr           * ) = 0;
-    virtual const ast::Expr *             visit( const ast::CountExpr            * ) = 0;
     virtual const ast::Expr *             visit( const ast::AlignofExpr          * ) = 0;
+    virtual const ast::Expr *             visit( const ast::CountofExpr          * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedOffsetofExpr  * ) = 0;
     virtual const ast::Expr *             visit( const ast::OffsetofExpr         * ) = 0;
Index: src/BasicTypes-gen.cpp
===================================================================
--- src/BasicTypes-gen.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/BasicTypes-gen.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -99,34 +99,34 @@
 
 	{ Float16, "Float16", "_FH", "_Float16", "DF16_", Floating, Float32, Float16Complex, -1, 7 },
-	{ Float16Complex, "Float16Complex", "_FHC", "_Float16 _Complex", "CDF16_", Floating, Float32Complex, -1, -1, 7 },
-
-	{ Float32, "Float32", "_F", "_Float32", "DF32_", Floating, Float, Float32Complex, -1, 8 },
-	{ Float32Complex, "Float32Complex", "_FC", "_Float32 _Complex", "CDF32_", Floating, FloatComplex, -1, -1, 8 },
-	{ Float, "Float", "F", "float", "f", Floating, Float32x, FloatComplex, -1, 9 },
-	{ FloatComplex, "FloatComplex", "FC", "float _Complex", "Cf", Floating, Float32xComplex, -1, -1, 9 },
-	{ Float32x, "Float32x", "_FX", "_Float32x", "DF32x_", Floating, Float64, Float32xComplex, -1, 10 },
-	{ Float32xComplex, "Float32xComplex", "_FXC", "_Float32x _Complex", "CDF32x_", Floating, Float64Complex, -1, -1, 10 },
-
-	{ Float64, "Float64", "_FD", "_Float64", "DF64_", Floating, Double, Float64Complex, -1, 11 },
-	{ Float64Complex, "Float64Complex", "_FDC", "_Float64 _Complex", "CDF64_", Floating, DoubleComplex, -1, -1, 11 },
-	{ Double, "Double", "D", "double", "d", Floating, Float64x, DoubleComplex, -1, 12 },
-	{ DoubleComplex, "DoubleComplex", "DC", "double _Complex", "Cd", Floating, Float64xComplex, -1, -1, 12 },
-	{ Float64x, "Float64x", "_FDX", "_Float64x", "DF64x_", Floating, Float80, Float64xComplex, -1, 13 },
-	{ Float64xComplex, "Float64xComplex", "_FDXC", "_Float64x _Complex", "CDF64x_", Floating, LongDoubleComplex, -1, -1, 13 },
-
-	{ Float80, "Float80", "_F80", "__float80", "Dq", Floating, LongDouble, LongDoubleComplex, -1, 14 },
+	{ Float16Complex, "Float16Complex", "_FHC", "_Float16 _Complex", "CDF16_", Floating, Float32Complex, -1, -1, 8 },
+
+	{ Float32, "Float32", "_F", "_Float32", "DF32_", Floating, Float, Float32Complex, -1, 9 },
+	{ Float32Complex, "Float32Complex", "_FC", "_Float32 _Complex", "CDF32_", Floating, FloatComplex, -1, -1, 10 },
+	{ Float, "Float", "F", "float", "f", Floating, Float32x, FloatComplex, -1, 11 },
+	{ FloatComplex, "FloatComplex", "FC", "float _Complex", "Cf", Floating, Float32xComplex, -1, -1, 12 },
+	{ Float32x, "Float32x", "_FX", "_Float32x", "DF32x_", Floating, Float64, Float32xComplex, -1, 13 },
+	{ Float32xComplex, "Float32xComplex", "_FXC", "_Float32x _Complex", "CDF32x_", Floating, Float64Complex, -1, -1, 14 },
+
+	{ Float64, "Float64", "_FD", "_Float64", "DF64_", Floating, Double, Float64Complex, -1, 15 },
+	{ Float64Complex, "Float64Complex", "_FDC", "_Float64 _Complex", "CDF64_", Floating, DoubleComplex, -1, -1, 16 },
+	{ Double, "Double", "D", "double", "d", Floating, Float64x, DoubleComplex, -1, 17 },
+	{ DoubleComplex, "DoubleComplex", "DC", "double _Complex", "Cd", Floating, Float64xComplex, -1, -1, 18 },
+	{ Float64x, "Float64x", "_FDX", "_Float64x", "DF64x_", Floating, Float80, Float64xComplex, -1, 19 },
+	{ Float64xComplex, "Float64xComplex", "_FDXC", "_Float64x _Complex", "CDF64x_", Floating, LongDoubleComplex, -1, -1, 20 },
+
+	{ Float80, "Float80", "_F80", "__float80", "Dq", Floating, LongDouble, LongDoubleComplex, -1, 21 },
 	// __float80 _Complex, no complex counterpart
 	// gcc implements long double as float80 (12 bytes)
-	{ LongDouble, "LongDouble", "LD", "long double", "e", Floating, uuFloat128, LongDoubleComplex, -1, 15 },
-	{ LongDoubleComplex, "LongDoubleComplex", "LDC", "long double _Complex", "Ce", Floating, Float128Complex, -1, -1, 15 },
-
-	{ uuFloat128, "uuFloat128", "__FLD", "__float128", "g", Floating, Float128, Float128Complex, -1, 16 },
+	{ LongDouble, "LongDouble", "LD", "long double", "e", Floating, uuFloat128, LongDoubleComplex, -1, 22 },
+	{ LongDoubleComplex, "LongDoubleComplex", "LDC", "long double _Complex", "Ce", Floating, Float128Complex, -1, -1, 23 },
+
+	{ uuFloat128, "uuFloat128", "__FLD", "__float128", "g", Floating, Float128, Float128Complex, -1, 24 },
 	// __float128 _Complex, no complex counterpart
-	{ Float128, "Float128", "_FLD", "_Float128", "DF128_", Floating, Float128x, Float128Complex, -1, 17 },
-	{ Float128Complex, "Float128Complex", "_FLDC", "_Float128 _Complex", "CDF128_", Floating, Float128xComplex, -1, -1, 17 },
+	{ Float128, "Float128", "_FLD", "_Float128", "DF128_", Floating, Float128x, Float128Complex, -1, 25 },
+	{ Float128Complex, "Float128Complex", "_FLDC", "_Float128 _Complex", "CDF128_", Floating, Float128xComplex, -1, -1, 26 },
 
 	// may not be supported
-	{ Float128x, "Float128x", "_FLDX", "_Float128x", "DF128x_", Floating, Float128xComplex, -1, -1, 18 },
-	{ Float128xComplex, "Float128xComplex", "_FLDXC", "_Float128x _Complex", "CDF128x_", Floating, -1, -1, -1, 18 }
+	{ Float128x, "Float128x", "_FLDX", "_Float128x", "DF128x_", Floating, Float128xComplex, -1, -1, 27 },
+	{ Float128xComplex, "Float128xComplex", "_FLDXC", "_Float128x _Complex", "CDF128x_", Floating, -1, -1, -1, 28 }
 }; // graph
 
@@ -135,5 +135,5 @@
 static Kind commonTypeMatrix[NUMBER_OF_BASIC_TYPES][NUMBER_OF_BASIC_TYPES];
 
-// Fangren explain shortest cost algorithm.
+// Compute the minimal conversion costs using Dijkstra's algorithm
 void generateCosts( int row ) {
 	bool seen[NUMBER_OF_BASIC_TYPES] = { false /*, ... */ };
@@ -176,5 +176,5 @@
 
 		// traverse children
-		// Fangren explain "max"
+		// any conversion should have a cost of at least 1, even if between types of equal rank
 		int i = graph[col].left;
 		if ( i == -1 ) continue;						// leaf
@@ -191,5 +191,8 @@
 } // generateCosts
 
-// Fangren explain this routine if you can.
+// Note: this algorithm is not general.
+// It relies on the specific structure of the conversion graph.
+// When the common type is not one of the two given types, we should always have a real and a complex floating point type,
+// in which case the common type is the next complex type ranked higher than the real type.
 void generateCommonType( int row, int col ) {			// row <= col
 	if ( costMatrix[row][col] >= 0 ) {
Index: src/CodeGen/CodeGenerator.cpp
===================================================================
--- src/CodeGen/CodeGenerator.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/CodeGen/CodeGenerator.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -251,5 +251,6 @@
 
 	if ( decl->init ) {
-		output << " = ";
+		bool isGenericInit = options.genC || decl->init->maybeConstructed;
+		output << ( (isGenericInit) ? " = " : " @= " );
 		decl->init->accept( *visitor );
 	}
Index: src/Common/CodeLocationTools.cpp
===================================================================
--- src/Common/CodeLocationTools.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/Common/CodeLocationTools.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -154,6 +154,6 @@
     macro(ConstantExpr, Expr) \
     macro(SizeofExpr, Expr) \
-    macro(CountExpr, Expr ) \
     macro(AlignofExpr, Expr) \
+    macro(CountofExpr, Expr ) \
     macro(UntypedOffsetofExpr, Expr) \
     macro(OffsetofExpr, Expr) \
Index: src/Concurrency/Keywords.cpp
===================================================================
--- src/Concurrency/Keywords.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/Concurrency/Keywords.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -10,6 +10,6 @@
 // Created On       : Tue Nov 16  9:53:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Dec 14 18:02:25 2023
-// Update Count     : 6
+// Last Modified On : Sun Jan 26 15:16:16 2025
+// Update Count     : 15
 //
 
@@ -69,6 +69,6 @@
 }
 
-// Describe that it adds the generic parameters and the uses of the generic
-// parameters on the function and first "this" argument.
+// Describe that it adds the generic parameters and the uses of the generic parameters on the
+// function and first "this" argument.
 ast::FunctionDecl * fixupGenerics(
 		const ast::FunctionDecl * func, const ast::StructDecl * decl ) {
@@ -117,4 +117,12 @@
 
 // --------------------------------------------------------------------------
+
+// This type describes the general information used to transform a generator, coroutine, monitor, or
+// thread aggregate kind.  A pass is made over the AST in ConcurrentSueKeyword::postvisit looking
+// for each of these kinds. When found, this data structure is filled in with the information from
+// the specific structures below, and handleStruct is called to perform the common changes that
+// augment the aggregate kind with fields and generate appropriate companion routines.  The location
+// of any extra fields is specified in addField.
+
 struct ConcurrentSueKeyword : public ast::WithDeclsToAdd {
 	ConcurrentSueKeyword(
@@ -171,25 +179,24 @@
 };
 
-// Handles thread type declarations:
+// Handles generator type declarations:
 //
-// thread Mythread {                         struct MyThread {
-//  int data;                                  int data;
-//  a_struct_t more_data;                      a_struct_t more_data;
-//                                =>             thread$ __thrd_d;
+// generator MyGenerator {                   struct MyGenerator {
+//                                =>             int __generator_state;
+//    int data;                                  int data;
+//    a_struct_t more_data;                      a_struct_t more_data;
 // };                                        };
-//                                           static inline thread$ * get_thread( MyThread * this ) { return &this->__thrd_d; }
 //
-struct ThreadKeyword final : public ConcurrentSueKeyword {
-	ThreadKeyword() : ConcurrentSueKeyword(
-		"thread$",
-		"__thrd",
-		"get_thread",
-		"thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
-		"ThreadCancelled",
+struct GeneratorKeyword final : public ConcurrentSueKeyword {
+	GeneratorKeyword() : ConcurrentSueKeyword(
+		"generator$",
+		"__generator_state",
+		"get_generator",
+		"Unable to find builtin type generator$\n",
+		"",
 		true,
-		ast::AggregateDecl::Thread )
+		ast::AggregateDecl::Generator )
 	{}
 
-	virtual ~ThreadKeyword() {}
+	virtual ~GeneratorKeyword() {}
 };
 
@@ -197,7 +204,7 @@
 //
 // coroutine MyCoroutine {                   struct MyCoroutine {
-//  int data;                                  int data;
-//  a_struct_t more_data;                      a_struct_t more_data;
 //                                =>             coroutine$ __cor_d;
+//    int data;                                  int data;
+//    a_struct_t more_data;                      a_struct_t more_data;
 // };                                        };
 //                                           static inline coroutine$ * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
@@ -220,7 +227,7 @@
 //
 // monitor MyMonitor {                       struct MyMonitor {
-//  int data;                                  int data;
-//  a_struct_t more_data;                      a_struct_t more_data;
 //                                =>             monitor$ __mon_d;
+//    int data;                                  int data;
+//    a_struct_t more_data;                      a_struct_t more_data;
 // };                                        };
 //                                           static inline monitor$ * get_coroutine( MyMonitor * this ) {
@@ -248,24 +255,25 @@
 };
 
-// Handles generator type declarations:
+// Handles thread type declarations:
 //
-// generator MyGenerator {                   struct MyGenerator {
-//  int data;                                  int data;
-//  a_struct_t more_data;                      a_struct_t more_data;
-//                                =>             int __generator_state;
+// thread Mythread {                         struct MyThread {
+//                                =>             thread$ __thrd_d;
+//    int data;                                  int data;
+//    a_struct_t more_data;                      a_struct_t more_data;
 // };                                        };
+//                                           static inline thread$ * get_thread( MyThread * this ) { return &this->__thrd_d; }
 //
-struct GeneratorKeyword final : public ConcurrentSueKeyword {
-	GeneratorKeyword() : ConcurrentSueKeyword(
-		"generator$",
-		"__generator_state",
-		"get_generator",
-		"Unable to find builtin type generator$\n",
-		"",
+struct ThreadKeyword final : public ConcurrentSueKeyword {
+	ThreadKeyword() : ConcurrentSueKeyword(
+		"thread$",
+		"__thrd",
+		"get_thread",
+		"thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+		"ThreadCancelled",
 		true,
-		ast::AggregateDecl::Generator )
+		ast::AggregateDecl::Thread )
 	{}
 
-	virtual ~GeneratorKeyword() {}
+	virtual ~ThreadKeyword() {}
 };
 
@@ -354,5 +362,5 @@
 
 	if ( !exception_name.empty() ) {
-		if( !typeid_decl || !vtable_decl ) {
+		if ( !typeid_decl || !vtable_decl ) {
 			SemanticError( decl, context_error );
 		}
@@ -419,6 +427,6 @@
 	declsToAddBefore.push_back(
 		Virtual::makeTypeIdInstance( location, typeid_type ) );
-	// If the typeid_type is going to be kept, the other reference will have
-	// been made by now, but we also get to avoid extra mutates.
+	// If the typeid_type is going to be kept, the other reference will have been made by now, but
+	// we also get to avoid extra mutates.
 	ast::ptr<ast::StructInstType> typeid_cleanup = typeid_type;
 }
@@ -525,4 +533,6 @@
 
 	auto mutDecl = ast::mutate( decl );
+	// Insert at start of special aggregate structures => front of vector
+	//mutDecl->members.insert( mutDecl->members.begin(), field );
 	mutDecl->members.push_back( field );
 
@@ -917,5 +927,5 @@
 
 			// If it is a monitor, then it is a monitor.
-			if( baseStruct->base->is_monitor() || baseStruct->base->is_thread() ) {
+			if ( baseStruct->base->is_monitor() || baseStruct->base->is_thread() ) {
 				SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters " );
 			}
@@ -1031,5 +1041,5 @@
 
 	// Make sure that only the outer reference is mutex.
-	if( baseStruct->is_mutex() ) {
+	if ( baseStruct->is_mutex() ) {
 		SemanticError( decl, "mutex keyword may only appear once per argument " );
 	}
@@ -1179,6 +1189,6 @@
 }
 
-// generates a cast to the void ptr to the appropriate lock type and dereferences it before calling lock or unlock on it
-// used to undo the type erasure done by storing all the lock pointers as void
+// Generates a cast to the void ptr to the appropriate lock type and dereferences it before calling
+// lock or unlock on it used to undo the type erasure done by storing all the lock pointers as void.
 ast::ExprStmt * MutexKeyword::genVirtLockUnlockExpr( const std::string & fnName, ast::ptr<ast::Expr> expr, const CodeLocation & location, ast::Expr * param ) {
 	return new ast::ExprStmt( location,
Index: src/InitTweak/GenInit.cpp
===================================================================
--- src/InitTweak/GenInit.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/InitTweak/GenInit.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -162,14 +162,35 @@
 				// FROM USER:  float a[ rand() ];
 				// TO GCC:     const size_t __len_of_a = rand(); float a[ __len_of_a ];
-
-				ast::ObjectDecl * arrayDimension = new ast::ObjectDecl(
-					arrayType->dimension->location,
-					dimensionName.newName(),
-					dimType,
-					new ast::SingleInit(
+				ast::ObjectDecl * arrayDimension = nullptr;
+
+				const ast::TypeExpr * ty = dynamic_cast< const ast::TypeExpr * >( arrayType->dimension.get() );
+				if ( ty ) {
+					auto inst = ty->type.as<ast::EnumInstType>();
+					if ( inst ) {
+						if ( inst->base->isCfa ) {
+							arrayDimension = new ast::ObjectDecl(
+								arrayType->dimension->location,
+								dimensionName.newName(),
+								new ast::BasicType( ast::BasicKind::UnsignedChar ),
+								new ast::SingleInit(
+									arrayType->dimension->location,
+									ast::ConstantExpr::from_int( arrayType->dimension->location, inst->base->members.size() )
+								)
+							);
+							// return arrayType;
+						}
+					}
+				}
+				if ( arrayDimension == nullptr ) {
+					arrayDimension = new ast::ObjectDecl(
 						arrayType->dimension->location,
-						arrayType->dimension
-					)
-				);
+						dimensionName.newName(),
+						dimType,
+						new ast::SingleInit(
+							arrayType->dimension->location,
+							arrayType->dimension
+						)
+					);
+				}
 
 				ast::ArrayType * mutType = ast::mutate( arrayType );
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/Parser/parser.yy	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -946,7 +946,7 @@
 		}
 	| COUNTOF unary_expression
-		{ $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuild( $2 ) ) ); }
+		{ $$ = new ExpressionNode( new ast::CountofExpr( yylloc, new ast::TypeofType( maybeMoveBuild( $2 ) ) ) ); }
 	| COUNTOF '(' type_no_function ')'
-		{ $$ = new ExpressionNode( new ast::CountExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
+		{ $$ = new ExpressionNode( new ast::CountofExpr( yylloc, maybeMoveBuildType( $3 ) ) ); }
 	;
 
Index: src/ResolvExpr/CandidateFinder.cpp
===================================================================
--- src/ResolvExpr/CandidateFinder.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/ResolvExpr/CandidateFinder.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -672,4 +672,5 @@
 		void postvisit( const ast::SizeofExpr * sizeofExpr );
 		void postvisit( const ast::AlignofExpr * alignofExpr );
+		void postvisit( const ast::CountofExpr * countExpr );
 		void postvisit( const ast::AddressExpr * addressExpr );
 		void postvisit( const ast::LabelAddressExpr * labelExpr );
@@ -697,5 +698,4 @@
 		void postvisit( const ast::UntypedInitExpr * initExpr );
 		void postvisit( const ast::QualifiedNameExpr * qualifiedExpr );
-		void postvisit( const ast::CountExpr * countExpr );
 
 		void postvisit( const ast::InitExpr * ) {
@@ -941,5 +941,4 @@
 		}
 	}
-	
 
 	/// Adds aggregate member interpretations
@@ -1269,5 +1268,5 @@
 					? conversionCost( fromType, toType, cand->expr->get_lvalue(), symtab, cand->env )
 					: castCost( fromType, toType, cand->expr->get_lvalue(), symtab, cand->env );
-			
+
 			// Redefine enum cast
 			auto argAsEnum = fromType.as<ast::EnumInstType>();
@@ -1493,20 +1492,13 @@
 	}
 
-	void Finder::postvisit( const ast::CountExpr * countExpr ) {
-		const ast::UntypedExpr * untyped = nullptr;
-		if ( countExpr->type ) {
-			auto enumInst = countExpr->type.as<ast::EnumInstType>();
-			if ( enumInst ) {
-				addCandidate( ast::ConstantExpr::from_ulong(countExpr->location, enumInst->base->members.size()), tenv );
-				return;
-			}
-			auto untypedFirst = ast::UntypedExpr::createCall( countExpr->location, "lowerBound", {} );
-			auto castFirst = new ast::CastExpr( countExpr->location, untypedFirst , countExpr->type );
-			untyped = ast::UntypedExpr::createCall(
-				countExpr->location, "Countof", { castFirst }
-			);
-		}
-		if (!untyped) untyped = ast::UntypedExpr::createCall(
-				countExpr->location, "Countof", { countExpr->expr }
+	void Finder::postvisit( const ast::CountofExpr * countExpr ) {
+		if ( auto enumInst = countExpr->type.as<ast::EnumInstType>() ) {
+			addCandidate( ast::ConstantExpr::from_ulong( countExpr->location, enumInst->base->members.size()), tenv );
+			return;
+		}
+		auto untypedFirst = ast::UntypedExpr::createCall( countExpr->location, "lowerBound", {} );
+		auto castFirst = new ast::CastExpr( countExpr->location, untypedFirst , countExpr->type );
+		const ast::UntypedExpr * untyped = ast::UntypedExpr::createCall(
+			countExpr->location, "Countof", { castFirst }
 		);
 		CandidateFinder finder( context, tenv );
@@ -1514,8 +1506,8 @@
 		CandidateList winners = findMinCost( finder.candidates );
 		if ( winners.size() == 0 ) {
-			SemanticError( countExpr->expr, "Countof is not implemented for operand: " );
-		}
-		if ( winners.size() !=  1 ) {
-			SemanticError( countExpr->expr, "Ambiguous expression in countof operand: " );
+			SemanticError( countExpr, "Countof is not implemented: " );
+		}
+		if ( winners.size() != 1 ) {
+			SemanticError( countExpr, "Ambiguous expression in countof: " );
 		}
 		CandidateRef & choice = winners.front();
Index: src/ResolvExpr/ConversionCost.cpp
===================================================================
--- src/ResolvExpr/ConversionCost.cpp	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ src/ResolvExpr/ConversionCost.cpp	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -44,16 +44,26 @@
 	          signed long long int     unsigned long long int
 	          __int128                 unsigned __int128
-	          _Float16                 _Float16 _Complex
-	          _Float32                 _Float32 _Complex
-	          float                    float _Complex
-	          _Float32x                _Float32x _Complex
-	          _Float64                 _Float64 _Complex
-	          double                   double _Complex
-	          _Float64x                _Float64x _Complex
+	                      _Float16
+	             _Float16 _Complex
+	                      _Float32
+	             _Float32 _Complex
+	                         float
+	                float _Complex
+	                     _Float32x
+	            _Float32x _Complex
+	                      _Float64
+	             _Float64 _Complex
+	                        double
+	               double _Complex
+	                     _Float64x
+	            _Float64x _Complex
 	                     __float80
-	          long double              long double _Complex
+	                   long double
+	          long double _Complex
 	                    __float128
-	          _Float128                _Float128 _Complex
-	          _Float128x               _Float128x _Complex
+	                     _Float128
+	            _Float128 _Complex
+	                    _Float128x
+	           _Float128x _Complex
 	*/
 	// GENERATED END
@@ -63,42 +73,42 @@
 	static const int costMatrix[ast::BasicKind::NUMBER_OF_BASIC_TYPES][ast::BasicKind::NUMBER_OF_BASIC_TYPES] = { // path length from root to node
 		/*               B    C   SC   UC   SI  USI    I   UI   LI  ULI  LLI ULLI __ID__UID  _FH _FHC   _F  _FC    F   FC  _FX _FXC  _FD _FDC    D   DC _FDX_FDXC _F80   LD  LDC__FLD _FLD_FLDC_FLDX_FLDXC */
-		/*      B */ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  15,  16,  17,  17,  18,  18, },
-		/*      C */ {  -1,   0,   1,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  16,  17,  17, },
-		/*     SC */ {  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  16,  17,  17, },
-		/*     UC */ {  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  14,  15,  16,  16,  17,  17, },
-		/*     SI */ {  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  15,  16,  16, },
-		/*    USI */ {  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  13,  14,  15,  15,  16,  16, },
-		/*      I */ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  14,  15,  15, },
-		/*     UI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  12,  13,  14,  14,  15,  15, },
-		/*     LI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  13,  14,  14, },
-		/*    ULI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  11,  12,  13,  13,  14,  14, },
-		/*    LLI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  12,  13,  13, },
-		/*   ULLI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  10,  11,  12,  12,  13,  13, },
-		/*   __ID */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  11,  12,  12, },
-		/*  __UID */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,   9,  10,  11,  11,  12,  12, },
-		/*    _FH */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   8,   9,  10,  10,  11,  11, },
-		/*   _FHC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,   6,  -1,  -1,   8,  -1,  -1,  10,  -1,  11, },
-		/*     _F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   9,   9,  10,  10, },
-		/*    _FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,   5,  -1,  -1,   7,  -1,  -1,   9,  -1,  10, },
-		/*      F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   8,   9,   9, },
-		/*     FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,   4,  -1,  -1,   6,  -1,  -1,   8,  -1,   9, },
-		/*    _FX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   7,   8,   8, },
-		/*   _FXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,   3,  -1,  -1,   5,  -1,  -1,   7,  -1,   8, },
-		/*    _FD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   6,   7,   7, },
-		/*   _FDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,   2,  -1,  -1,   4,  -1,  -1,   6,  -1,   7, },
-		/*      D */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   5,   6,   6, },
-		/*     DC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1,  -1,  -1,   3,  -1,  -1,   5,  -1,   6, },
-		/*   _FDX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   4,   5,   5, },
-		/*  _FDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   2,  -1,  -1,   4,  -1,   5, },
-		/*   _F80 */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   3,   4,   4, },
-		/*     LD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3, },
-		/*    LDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   2,  -1,   3, },
-		/*  __FLD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2, },
-		/*   _FLD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2, },
-		/*  _FLDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   1, },
+		/*      B */ {   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28, },
+		/*      C */ {  -1,   0,   1,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27, },
+		/*     SC */ {  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27, },
+		/*     UC */ {  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27, },
+		/*     SI */ {  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26, },
+		/*    USI */ {  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26, },
+		/*      I */ {  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25, },
+		/*     UI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25, },
+		/*     LI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24, },
+		/*    ULI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24, },
+		/*    LLI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23, },
+		/*   ULLI */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23, },
+		/*   __ID */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22, },
+		/*  __UID */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22, },
+		/*    _FH */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21, },
+		/*   _FHC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2,  -1,   4,  -1,   6,  -1,   8,  -1,  10,  -1,  12,  -1,  -1,  15,  -1,  -1,  18,  -1,  20, },
+		/*     _F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17,  18,  19, },
+		/*    _FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2,  -1,   4,  -1,   6,  -1,   8,  -1,  10,  -1,  -1,  13,  -1,  -1,  16,  -1,  18, },
+		/*      F */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,  16,  17, },
+		/*     FC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2,  -1,   4,  -1,   6,  -1,   8,  -1,  -1,  11,  -1,  -1,  14,  -1,  16, },
+		/*    _FX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15, },
+		/*   _FXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2,  -1,   4,  -1,   6,  -1,  -1,   9,  -1,  -1,  12,  -1,  14, },
+		/*    _FD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13, },
+		/*   _FDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2,  -1,   4,  -1,  -1,   7,  -1,  -1,  10,  -1,  12, },
+		/*      D */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11, },
+		/*     DC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2,  -1,  -1,   5,  -1,  -1,   8,  -1,  10, },
+		/*   _FDX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9, },
+		/*  _FDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   3,  -1,  -1,   6,  -1,   8, },
+		/*   _F80 */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6,   7, },
+		/*     LD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4,   5,   6, },
+		/*    LDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,  -1,   3,  -1,   5, },
+		/*  __FLD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3,   4, },
+		/*   _FLD */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1,   2,   3, },
+		/*  _FLDC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,  -1,   2, },
 		/*  _FLDX */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0,   1, },
 		/* _FLDXC */ {  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,   0, },
 	}; // costMatrix
-	static const int maxIntCost = 15;
+	static const int maxIntCost = 25;
 	// GENERATED END
 	static_assert(
Index: tests/.expect/arithmeticConversions.arm64.txt
===================================================================
--- tests/.expect/arithmeticConversions.arm64.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/.expect/arithmeticConversions.arm64.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,57 @@
+integral + integral
+               c   sc   uc  ssi  usi   si   ui  sli  uli slli ulli
+  bytes        1    1    1    2    2    4    4    8    8    8    8
+          + ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+     c  1 |    1    1    1    2    2    4    4    8    8    8    8
+    sc  1 |    1    1    1    2    2    4    4    8    8    8    8
+    uc  1 |    1    1    1    2    2    4    4    8    8    8    8
+   ssi  2 |    2    2    2    2    2    4    4    8    8    8    8
+   usi  2 |    2    2    2    2    2    4    4    8    8    8    8
+    si  4 |    4    4    4    4    4    4    4    8    8    8    8
+    ui  4 |    4    4    4    4    4    4    4    8    8    8    8
+   sli  8 |    8    8    8    8    8    8    8    8    8    8    8
+   uli  8 |    8    8    8    8    8    8    8    8    8    8    8
+  slli  8 |    8    8    8    8    8    8    8    8    8    8    8
+  ulli  8 |    8    8    8    8    8    8    8    8    8    8    8
+
+float + integral
+               c   sc   uc  ssi  usi   si   ui  sli  uli slli ulli
+  bytes        1    1    1    2    2    4    4    8    8    8    8
+          + ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+   f32  4 |    4    4    4    4    4    4    4    4    4    4    4
+  f32c  8 |    8    8    8    8    8    8    8    8    8    8    8
+     f  4 |    4    4    4    4    4    4    4    4    4    4    4
+    fc  8 |    8    8    8    8    8    8    8    8    8    8    8
+  f32x  8 |    8    8    8    8    8    8    8    8    8    8    8
+ f32xc 16 |   16   16   16   16   16   16   16   16   16   16   16
+   f64  8 |    8    8    8    8    8    8    8    8    8    8    8
+  f64c 16 |   16   16   16   16   16   16   16   16   16   16   16
+     d  8 |    8    8    8    8    8    8    8    8    8    8    8
+    dc 16 |   16   16   16   16   16   16   16   16   16   16   16
+  f64x 16 |   16   16   16   16   16   16   16   16   16   16   16
+ f64xc 32 |   32   32   32   32   32   32   32   32   32   32   32
+    ld 16 |   16   16   16   16   16   16   16   16   16   16   16
+   ldc 32 |   32   32   32   32   32   32   32   32   32   32   32
+  f128 16 |   16   16   16   16   16   16   16   16   16   16   16
+ f128c 32 |   32   32   32   32   32   32   32   32   32   32   32
+
+float + float
+              f32  f32c     f    fc  f32x f32xc   f64  f64c     d    dc  f64x f64xc    ld   ldc  f128 f128c
+  bytes         4     8     4     8     8    16     8    16     8    16    16    32    16    32    16    32
+          + ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ------
+   f32  4 |     4     8     4     8     8    16     8    16     8    16    16    32    16    32    16    32
+  f32c  8 |     8     8     8     8    16    16    16    16    16    16    32    32    32    32    32    32
+     f  4 |     4     8     4     8     8    16     8    16     8    16    16    32    16    32    16    32
+    fc  8 |     8     8     8     8    16    16    16    16    16    16    32    32    32    32    32    32
+  f32x  8 |     8    16     8    16     8    16     8    16     8    16    16    32    16    32    16    32
+ f32xc 16 |    16    16    16    16    16    16    16    16    16    16    32    32    32    32    32    32
+   f64  8 |     8    16     8    16     8    16     8    16     8    16    16    32    16    32    16    32
+  f64c 16 |    16    16    16    16    16    16    16    16    16    16    32    32    32    32    32    32
+     d  8 |     8    16     8    16     8    16     8    16     8    16    16    32    16    32    16    32
+    dc 16 |    16    16    16    16    16    16    16    16    16    16    32    32    32    32    32    32
+  f64x 16 |    16    32    16    32    16    32    16    32    16    32    16    32    16    32    16    32
+ f64xc 32 |    32    32    32    32    32    32    32    32    32    32    32    32    32    32    32    32
+    ld 16 |    16    32    16    32    16    32    16    32    16    32    16    32    16    32    16    32
+   ldc 32 |    32    32    32    32    32    32    32    32    32    32    32    32    32    32    32    32
+  f128 16 |    16    32    16    32    16    32    16    32    16    32    16    32    16    32    16    32
+ f128c 32 |    32    32    32    32    32    32    32    32    32    32    32    32    32    32    32    32
Index: tests/arithmeticConversions.cfa
===================================================================
--- tests/arithmeticConversions.cfa	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ tests/arithmeticConversions.cfa	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -98,16 +98,20 @@
 	printf( "%6s %2zd | %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd\n",
 		ST(f64xc), SZ(f64xc), SZ(f64xc + c), SZ(f64xc + sc), SZ(f64xc + uc), SZ(f64xc + ssi), SZ(f64xc + usi), SZ(f64xc + si), SZ(f64xc + ui), SZ(f64xc + sli), SZ(f64xc + ulli), SZ(f64xc + ulli), SZ(f64xc + ulli) );
-#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
+
+	#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
 	printf( "%6s %2zd | %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd\n",
 		ST(f80), SZ(f80), SZ(f80 + c), SZ(f80 + sc), SZ(f80 + uc), SZ(f80 + ssi), SZ(f80 + usi), SZ(f80 + si), SZ(f80 + ui), SZ(f80 + sli), SZ(f80 + ulli), SZ(f80 + ulli), SZ(f80 + ulli) );
-#endif
+	#endif
+
 	printf( "%6s %2zd | %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd\n",
 		ST(ld), SZ(ld), SZ(ld + c), SZ(ld + sc), SZ(ld + uc), SZ(ld + ssi), SZ(ld + usi), SZ(ld + si), SZ(ld + ui), SZ(ld + sli), SZ(ld + ulli), SZ(ld + ulli), SZ(ld + ulli) );
 	printf( "%6s %2zd | %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd\n",
 		ST(ldc), SZ(ldc), SZ(ldc + c), SZ(ldc + sc), SZ(ldc + uc), SZ(ldc + ssi), SZ(ldc + usi), SZ(ldc + si), SZ(ldc + ui), SZ(ldc + sli), SZ(ldc + ulli), SZ(ldc + ulli), SZ(ldc + ulli) );
-#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
+
+	#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
 	printf( "%6s %2zd | %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd\n",
 		ST(uuf128), SZ(uuf128), SZ(uuf128 + c), SZ(uuf128 + sc), SZ(uuf128 + uc), SZ(uuf128 + ssi), SZ(uuf128 + usi), SZ(uuf128 + si), SZ(uuf128 + ui), SZ(uuf128 + sli), SZ(uuf128 + ulli), SZ(uuf128 + ulli), SZ(uuf128 + ulli) );
-#endif
+	#endif
+
 	printf( "%6s %2zd | %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd %4zd\n",
 		ST(f128), SZ(f128), SZ(f128 + c), SZ(f128 + sc), SZ(f128 + uc), SZ(f128 + ssi), SZ(f128 + usi), SZ(f128 + si), SZ(f128 + ui), SZ(f128 + sli), SZ(f128 + ulli), SZ(f128 + ulli), SZ(f128 + ulli) );
@@ -146,16 +150,20 @@
 	printf( "%6s %2zd | %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd" OPT1(" %5zd") " %5zd %5zd" OPT1(" %6zd") " %5zd %5zd\n",
 		ST(f64xc), SZ(f64xc), SZ(f64xc + f32), SZ(f64xc + f32c), SZ(f64xc + f), SZ(f64xc + fc), SZ(f64xc + f32x), SZ(f64xc + f32xc), SZ(f64xc + f64), SZ(f64xc + f64c), SZ(f64xc + d), SZ(f64xc + dc), SZ(f64xc + f64x), SZ(f64xc + f64xc) OPT2(, SZ(f64xc + f80)), SZ(f64xc + ld), SZ(f64xc + ldc) OPT2(, SZ(f64xc + uuf128)), SZ(f64xc + f128), SZ(f64xc + f128c) );
-#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
+
+	#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
 	printf( "%6s %2zd | %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %6zd %5zd %5zd\n",
 			ST(f80), SZ(f80), SZ(f80 + f32), SZ(f80 + f32c), SZ(f80 + f), SZ(f80 + fc), SZ(f80 + f32x), SZ(f80 + f32xc), SZ(f80 + f64), SZ(f80 + f64c), SZ(f80 + d), SZ(f80 + dc), SZ(f80 + f64x), SZ(f80 + f64xc), SZ(f80 + f80), SZ(f80 + ld), SZ(f80 + ldc), SZ(f80 + uuf128), SZ(f80 + f128), SZ(f80 + f128c) );
-#endif
+	#endif
+
 	printf( "%6s %2zd | %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd" OPT1(" %5zd") " %5zd %5zd" OPT1(" %6zd") " %5zd %5zd\n",
 		ST(ld), SZ(ld), SZ(ld + f32), SZ(ld + f32c), SZ(ld + f), SZ(ld + fc), SZ(ld + f32x), SZ(ld + f32xc), SZ(ld + f64), SZ(ld + f64c), SZ(ld + d), SZ(ld + dc), SZ(ld + f64x), SZ(ld + f64xc) OPT2(, SZ(ld + f80)), SZ(ld + ld), SZ(ld + ldc) OPT2(, SZ(ld + uuf128)), SZ(ld + f128), SZ(ld + f128c) );
 	printf( "%6s %2zd | %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd" OPT1(" %5zd") " %5zd %5zd" OPT1(" %6zd") " %5zd %5zd\n",
 		ST(ldc), SZ(ldc), SZ(ldc + f32), SZ(ldc + f32c), SZ(ldc + f), SZ(ldc + fc), SZ(ldc + f32x), SZ(ldc + f32xc), SZ(ldc + f64), SZ(ldc + f64c), SZ(ldc + d), SZ(ldc + dc), SZ(ldc + f64x), SZ(ldc + f64xc) OPT2(, SZ(ldc + f80)), SZ(ldc + ld), SZ(ldc + ldc) OPT2(, SZ(ldc + uuf128)), SZ(ldc + f128), SZ(ldc + f128c) );
-#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
+
+	#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
 	printf( "%6s %2zd | %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %6zd %5zd %5zd\n",
 		ST(uuf128), SZ(uuf128), SZ(uuf128 + f32), SZ(uuf128 + f32c), SZ(uuf128 + f), SZ(uuf128 + fc), SZ(uuf128 + f32x), SZ(uuf128 + f32xc), SZ(uuf128 + f64), SZ(uuf128 + f64c), SZ(uuf128 + d), SZ(uuf128 + dc), SZ(uuf128 + f64x), SZ(uuf128 + f64xc), SZ(uuf128 + f80), SZ(uuf128 + ld), SZ(uuf128 + ldc), SZ(uuf128 + uuf128), SZ(uuf128 + f128), SZ(uuf128 + f128c) );
-#endif
+	#endif
+
 	printf( "%6s %2zd | %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd %5zd" OPT1(" %5zd") " %5zd %5zd" OPT1(" %6zd") " %5zd %5zd\n",
 		ST(f128), SZ(f128), SZ(f128 + f32), SZ(f128 + f32c), SZ(f128 + f), SZ(f128 + fc), SZ(f128 + f32x), SZ(f128 + f32xc), SZ(f128 + f64), SZ(f128 + f64c), SZ(f128 + d), SZ(f128 + dc), SZ(f128 + f64x), SZ(f128 + f64xc) OPT2(, SZ(f128 + f80)), SZ(f128 + ld), SZ(f128 + ldc) OPT2(, SZ(f128 + uuf128)), SZ(f128 + f128), SZ(f128 + f128c) );
Index: tests/array-collections/boxed.bookend.cfa
===================================================================
--- tests/array-collections/boxed.bookend.cfa	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ tests/array-collections/boxed.bookend.cfa	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -27,4 +27,10 @@
 static char * bookend_hi = 0p;
 
+// bookend pointers are set to stack addresses and compared (but not dereferenced)
+// after their functions exit; they are "dangling"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpragmas" // -Wdangling-pointer unrecognized until GCC 12
+#pragma GCC diagnostic ignored "-Wdangling-pointer"
+
 void bookendInner( void ) {
     char var = 'x';
@@ -35,13 +41,15 @@
 #define TC(...)
 #define TR( TRID, SZS, SZV, ETG, ACCS, SPS, OVLD ) \
-    F_SIG( bookendOuter, TRID, SZS, SZV, ACCS, SPS, OVLD ) {                                  \
+    F_SIG( bookendOuter, TRID, SZS, SZV, ACCS, SPS, OVLD ) {                         \
         char var = 'x';                                                              \
         (void) var;                                                                  \
         bookend_hi = & var;                                                          \
-        return CALL( allocAndAccess, TRID, SZS, n, expectedElmSz, tcid, vart );     \
+        return CALL( allocAndAccess, TRID, SZS, n, expectedElmSz, tcid, vart );      \
     }
 #include "boxed.cases.hfa"
 #undef TC
 #undef TR
+
+#pragma GCC diagnostic pop
 
 void resetBookends( void ) {
Index: tests/io/.expect/eofType.txt
===================================================================
--- tests/io/.expect/eofType.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.expect/eofType.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,40 @@
+false
+false
+true
+eof
+false
+true
+false
+eof
+a
+b
+c
+eof
+a
+b
+c
+eof
+1
+2
+3
+eof
+1
+2
+3
+eof
+1.5
+2.5
+3.5
+eof
+1.5
+2.5
+3.5
+eof
+1.5+1.i
+2.5+1.i
+3.5+1.i
+eof
+1.5+1.i
+2.5+1.i
+3.5+1.i
+eof
Index: tests/io/.in/eofType.bool.1.txt
===================================================================
--- tests/io/.in/eofType.bool.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.bool.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+    false   false  true
Index: tests/io/.in/eofType.bool.2.txt
===================================================================
--- tests/io/.in/eofType.bool.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.bool.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+    false  true   false
Index: tests/io/.in/eofType.char.1.txt
===================================================================
--- tests/io/.in/eofType.char.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.char.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+abc
Index: tests/io/.in/eofType.char.2.txt
===================================================================
--- tests/io/.in/eofType.char.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.char.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+abc
Index: tests/io/.in/eofType.complex.1.txt
===================================================================
--- tests/io/.in/eofType.complex.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.complex.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+1.5+1.0 2.5+1.0 3.5+1.0
Index: tests/io/.in/eofType.complex.2.txt
===================================================================
--- tests/io/.in/eofType.complex.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.complex.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+1.5+1.0 2.5+1.0 3.5+1.0
Index: tests/io/.in/eofType.double.1.txt
===================================================================
--- tests/io/.in/eofType.double.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.double.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+1.5 2.5 3.5
Index: tests/io/.in/eofType.double.2.txt
===================================================================
--- tests/io/.in/eofType.double.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.double.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+1.5 2.5 3.5
Index: tests/io/.in/eofType.int.1.txt
===================================================================
--- tests/io/.in/eofType.int.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.int.1.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+1 2 3
Index: tests/io/.in/eofType.int.2.txt
===================================================================
--- tests/io/.in/eofType.int.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/.in/eofType.int.2.txt	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,1 @@
+1 2 3
Index: tests/io/eofType.cfa
===================================================================
--- tests/io/eofType.cfa	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
+++ tests/io/eofType.cfa	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -0,0 +1,119 @@
+// 
+// Cforall Version 1.0.0 Copyright (C) 2025 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// 
+// eofType.cfa -- Test for end-of-file with and without a terminating newline across multiple types.
+// 
+// Author           : Peter A. Buhr
+// Created On       : Wed Jan 22 07:41:41 2025
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Jan 23 14:33:08 2025
+// Update Count     : 9
+// 
+
+#include <fstream.hfa>									// sin/sout
+
+void openfile( ifstream & testfile, const char * filename ) { // helper
+	try {
+		open( testfile, filename );
+	} catch( open_failure * ex; ex->istream == &testfile ) { // input file errors
+		exit | "Unable to open input file \"" | filename | "\"";
+	} // try
+}
+
+// test.py provides macro IN_DIR, which is the absolute path to the current .in directory
+#define xstr(s) str(s)
+#define str(s) #s
+// Add quotes around directory name.
+#define INDIR xstr(IN_DIR)
+
+int main() {
+	ifstream testfile;
+	{
+		char * filenames[] = { INDIR "eofType.bool.1.txt", INDIR "eofType.bool.2.txt" };
+		bool value;
+
+		for ( i; 2 ) {
+			openfile( testfile, filenames[i] );
+			try {
+				for () {
+					testfile | value;
+					sout | value;
+				} // for
+			} catch( end_of_file * ) {
+				sout | "eof";
+			} // try
+			close( testfile );
+		}
+	}
+	{
+		char * filenames[] = { INDIR "eofType.char.1.txt", INDIR "eofType.char.2.txt" };
+		char value;
+
+		for ( i; 2 ) {
+			openfile( testfile, filenames[i] );
+			try {
+				for () {
+					testfile | value;
+					sout | value;
+				} // for
+			} catch( end_of_file * ) {
+				sout | "eof";
+			} // try
+			close( testfile );
+		}
+	}
+	{
+		char * filenames[] = { INDIR "eofType.int.1.txt", INDIR "eofType.int.2.txt" };
+		int value;
+
+		for ( i; 2 ) {
+			openfile( testfile, filenames[i] );
+			try {
+				for () {
+					testfile | value;
+					sout | value;
+				} // for
+			} catch( end_of_file * ) {
+				sout | "eof";
+			} // try
+			close( testfile );
+		}
+	}
+	{
+		char * filenames[] = { INDIR "eofType.double.1.txt", INDIR "eofType.double.2.txt" };
+		double value;
+
+		for ( i; 2 ) {
+			openfile( testfile, filenames[i] );
+			try {
+				for () {
+					testfile | value;
+					sout | value;
+				} // for
+			} catch( end_of_file * ) {
+				sout | "eof";
+			} // try
+			close( testfile );
+		}
+	}
+	{
+		char * filenames[] = { INDIR "eofType.complex.1.txt", INDIR "eofType.complex.2.txt" };
+		_Complex value;
+
+		for ( i; 2 ) {
+			openfile( testfile, filenames[i] );
+			try {
+				for () {
+					testfile | value;
+					sout | value;
+				} // for
+			} catch( end_of_file * ) {
+				sout | "eof";
+			} // try
+			close( testfile );
+		}
+	}
+} // main
Index: tests/malloc.cfa
===================================================================
--- tests/malloc.cfa	(revision 0f070a45d2767ae371eb4be4dd8bac7a57fd2846)
+++ tests/malloc.cfa	(revision de8a0a4b93508e4ad5a8d0566ef090c279f489b2)
@@ -64,5 +64,9 @@
 	free( ip );
 
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wpragmas" // -Walloc-size unrecognized until GCC 14
+  #pragma GCC diagnostic ignored "-Walloc-size"
 	ip = (int *)malloc( 0 );
+  #pragma GCC diagnostic pop
 	test_base( ip, 0, libAlign );
 	test_use( ip );