Index: src/prelude/builtins.c
===================================================================
--- src/prelude/builtins.c	(revision a1edafa4cdaef39b89d777ace0514d4622c8c81b)
+++ src/prelude/builtins.c	(revision 15d1cc37ed69aa60f755b2dddff96571b3b67964)
@@ -10,6 +10,6 @@
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 17:01:54 2017
-// Update Count     : 11
+// Last Modified On : Sat Jul 22 10:34:20 2017
+// Update Count     : 13
 // 
 
@@ -38,41 +38,41 @@
 static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
 
-static inline long int ?\?( long int pe, unsigned long y ) { // disallow negative exponent
+static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
 	if ( y == 0 ) return 1;								// base case
-    if ( pe == 2 ) return pe << (y - 1);				// special case, positive shifting only
-    typeof( pe ) po = 1;								// accumulate odd product
+    if ( ep == 2 ) return ep << (y - 1);				// special case, positive shifting only
+    typeof( ep ) op = 1;								// accumulate odd product
     for ( ; y > 1; y >>= 1 ) {							// squaring exponentiation, O(log2 y)
-		if ( (y & 1) == 1 ) po *= pe;					// odd ?
-		pe *= pe;
-	} // while
-    return pe * po;
+		if ( (y & 1) == 1 ) op *= ep;					// odd ?
+		ep *= ep;
+	} // for
+    return ep * op;
 } // ?\?
 
-// FIX ME, cannot resolve the "T po = 1".
+// FIX ME, cannot resolve the "T op = 1".
 
 // static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); } )
-// T ?\?( T pe, unsigned long y ) {
+// T ?\?( T ep, unsigned long int y ) {
 //     if ( y == 0 ) return 1;
-//     T po = 1;
+//     T op = 1;
 //     for ( ; y > 1; y >>= 1 ) {							// squaring exponentiation, O(log2 y)
-// 		if ( (y & 1) == 1 ) po = po * pe;				// odd ?
-// 		pe = pe * pe;
+// 		if ( (y & 1) == 1 ) op = op * ep;				// odd ?
+// 		ep = ep * ep;
 //     } // for
-//     return pe * po;
+//     return ep * op;
 // } // ?\?
 
 // unsigned computation may be faster and larger
-static inline unsigned long int ?\?( unsigned long int pe, unsigned long y ) { // disallow negative exponent
+static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
 	if ( y == 0 ) return 1;								// base case
-    if ( pe == 2 ) return pe << (y - 1);				// special case, positive shifting only
-    typeof( pe ) po = 1;								// accumulate odd product
+    if ( ep == 2 ) return ep << (y - 1);				// special case, positive shifting only
+    typeof( ep ) op = 1;								// accumulate odd product
     for ( ; y > 1; y >>= 1 ) {							// squaring exponentiation, O(log2 y)
-		if ( (y & 1) == 1 ) po *= pe;					// odd ?
-		pe *= pe;
-	} // while
-    return pe * po;
+		if ( (y & 1) == 1 ) op *= ep;					// odd ?
+		ep *= ep;
+	} // for
+    return ep * op;
 } // ?\?
 
-static inline double ?\?( long int x, signed long y ) {	// allow negative exponent
+static inline double ?\?( long int x, signed long int y ) {	// allow negative exponent
     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
     else return 1.0 / x \ (unsigned int)(-y);
@@ -80,13 +80,13 @@
 
 static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
-double ?\?( T x, signed long y ) {
+double ?\?( T x, signed long int y ) {
     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
-    else return 1.0 / x \ (unsigned int)(-y);
+    else return 1.0 / x \ (unsigned long int)(-y);
 } // ?\?
 
-static inline long int ?\=?( long int * x, unsigned long y ) { *x = *x \ y; return *x; }
-static inline long int ?\=?( unsigned long int * x, unsigned long y ) { *x = *x \ y; return *x; }
-static inline int ?\=?( int * x, unsigned long y ) { *x = *x \ y; return *x; }
-static inline int ?\=?( unsigned int * x, unsigned long y ) { *x = *x \ y; return *x; }
+static inline long int ?\=?( long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline unsigned long int ?\=?( unsigned long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline int ?\=?( int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline unsigned int ?\=?( unsigned int * x, unsigned long int y ) { *x = *x \ y; return *x; }
 
 // Local Variables: //
