Index: doc/papers/concurrency/Paper.tex
===================================================================
--- doc/papers/concurrency/Paper.tex	(revision d046db2ac11262165d9c13d2f62d3fff987a4f36)
+++ doc/papers/concurrency/Paper.tex	(revision 399a908cc97cdaad27d16bbf3d5672d0e4db6110)
@@ -19,5 +19,6 @@
 \usepackage{listings}						% format program code
 \usepackage[labelformat=simple,aboveskip=0pt,farskip=0pt]{subfig}
-\renewcommand{\thesubfigure}{(\alph{subfigure})}
+\renewcommand{\thesubfigure}{(\Alph{subfigure})}
+\captionsetup{justification=raggedright,singlelinecheck=false}
 \usepackage{siunitx}
 \sisetup{ binary-units=true }
@@ -98,5 +99,5 @@
 \newcommand{\abbrevFont}{\textit}			% set empty for no italics
 \@ifundefined{eg}{
-\newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
+\newcommand{\EG}{\abbrevFont{e}\abbrevFont{g}}
 \newcommand*{\eg}{%
 	\@ifnextchar{,}{\EG}%
@@ -105,5 +106,5 @@
 }}{}%
 \@ifundefined{ie}{
-\newcommand{\IE}{\abbrevFont{i}.\abbrevFont{e}.}
+\newcommand{\IE}{\abbrevFont{i}\abbrevFont{e}}
 \newcommand*{\ie}{%
 	\@ifnextchar{,}{\IE}%
@@ -143,5 +144,5 @@
 		_Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
 		auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
-		coroutine, disable, dtype, enable, __extension__, exception, fallthrough, fallthru, finally,
+		coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
 		__float80, float80, __float128, float128, forall, ftype, _Generic, _Imaginary, __imag, __imag__,
 		inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
@@ -169,5 +170,5 @@
 literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
 	{~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 % {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
-	{<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.5ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
+	{<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
 moredelim=**[is][\color{red}]{`}{`},
 }% lstset
@@ -216,16 +217,16 @@
 \author[1]{Thierry Delisle}
 \author[1]{Peter A. Buhr*}
-\authormark{Thierry Delisle \textsc{et al}}
-
-\address[1]{\orgdiv{Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Ontario}, \country{Canada}}}
-
-\corres{*Peter A. Buhr, \email{pabuhr{\char`\@}uwaterloo.ca}}
-\presentaddress{Cheriton School of Computer Science, University of Waterloo, Waterloo, ON, N2L 3G1, Canada}
-
+\authormark{DELISLE \textsc{et al.}}
+
+\address[1]{\orgdiv{Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Waterloo, ON}, \country{Canada}}}
+
+\corres{*Peter A. Buhr, Cheriton School of Computer Science, University of Waterloo, 200 University Avenue West, Waterloo, ON, N2L 3G1, Canada. \email{pabuhr{\char`\@}uwaterloo.ca}}
+
+\fundingInfo{Natural Sciences and Engineering Research Council of Canada}
 
 \abstract[Summary]{
 \CFA is a modern, polymorphic, \emph{non-object-oriented} extension of the C programming language.
 This paper discusses the design of the concurrency and parallelism features in \CFA, and the concurrent runtime-system.
-These features are created from scratch as ISO C lacks concurrency, relying largely on pthreads.
+These features are created from scratch as ISO C lacks concurrency, relying largely on pthreads library.
 Coroutines and lightweight (user) threads are introduced into the language.
 In addition, monitors are added as a high-level mechanism for mutual exclusion and synchronization.
@@ -255,15 +256,15 @@
 Examples of high-level approaches are task based~\cite{TBB}, message passing~\cite{Erlang,MPI}, and implicit threading~\cite{OpenMP}.
 
-This paper used the following terminology.
+This paper uses the following terminology.
 A \newterm{thread} is a fundamental unit of execution that runs a sequence of code and requires a stack to maintain state.
-Multiple simultaneous threads gives rise to \newterm{concurrency}, which requires locking to ensure safe communication and access to shared data.
+Multiple simultaneous threads give rise to \newterm{concurrency}, which requires locking to ensure safe communication and access to shared data.
 % Correspondingly, concurrency is defined as the concepts and challenges that occur when multiple independent (sharing memory, timing dependencies, \etc) concurrent threads are introduced.
 \newterm{Locking}, and by extension locks, are defined as a mechanism to prevent progress of threads to provide safety.
 \newterm{Parallelism} is running multiple threads simultaneously.
 Parallelism implies \emph{actual} simultaneous execution, where concurrency only requires \emph{apparent} simultaneous execution.
-As such, parallelism is only observable in differences in performance, which is observed through differences in timing.
+As such, parallelism only affects performance, which is observed through differences in space and/or time.
 
 Hence, there are two problems to be solved in the design of concurrency for a programming language: concurrency and parallelism.
-While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite[\S~2]{Buhr05a}.
+While these two concepts are often combined, they are distinct, requiring different tools~\cite[\S~2]{Buhr05a}.
 Concurrency tools handle synchronization and mutual exclusion, while parallelism tools handle performance, cost and resource utilization.
 
@@ -278,12 +279,12 @@
 
 The following is a quick introduction to the \CFA language, specifically tailored to the features needed to support concurrency.
-
-\CFA is an extension of ISO-C and therefore supports all of the same paradigms as C.
-It is a non-object-oriented system-language, meaning most of the major abstractions have either no runtime overhead or can be opted out easily.
+Most of the following code examples can be found on the \CFA website~\cite{Cforall}.
+
+\CFA is an extension of ISO-C, and therefore, supports all of the same paradigms as C.
+%It is a non-object-oriented system-language, meaning most of the major abstractions have either no runtime overhead or can be opted out easily.
 Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over machine code.
 The vast majority of the code produced by the \CFA translator respects memory layouts and calling conventions laid out by C.
-Interestingly, while \CFA is not an object-oriented language, lacking the concept of a receiver (\eg {\tt this}), it does have some notion of objects\footnote{C defines the term objects as : ``region of data storage in the execution environment, the contents of which can represent
+Interestingly, while \CFA is not an object-oriented language, lacking the concept of a receiver (\eg @this@) and inheritance, it does have some notion of objects\footnote{C defines the term objects as : ``region of data storage in the execution environment, the contents of which can represent
 values''~\cite[3.15]{C11}}, most importantly construction and destruction of objects.
-Most of the following code examples can be found on the \CFA website~\cite{Cforall}.
 
 
@@ -293,15 +294,18 @@
 In regards to concurrency, the semantic difference between pointers and references are not particularly relevant, but since this document uses mostly references, here is a quick overview of the semantics:
 \begin{cfa}
-int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
-	&r1 = x,    &&r2 = r1,   &&&r3 = r2;
-***p3 = 3;							$\C{// change x}$
-r3    = 3;							$\C{// change x, ***r3}$
-**p3  = ...;						$\C{// change p1}$
-*p3   = ...;						$\C{// change p2}$
-int y, z, & ar[3] = {x, y, z};		$\C{// initialize array of references}$
-typeof( ar[1]) p;					$\C{// is int, referenced object type}$
-typeof(&ar[1]) q;					$\C{// is int \&, reference type}$
-sizeof( ar[1]) == sizeof(int);		$\C{// is true, referenced object size}$
-sizeof(&ar[1]) == sizeof(int *);	$\C{// is true, reference size}$
+int x, y, z;
+int * p1 = &x, ** p2 = &p1, *** p3 = &p2,	$\C{// pointers to x}$
+	& r1 = x,   && r2 = r1, &&& r3 = r2;	$\C{// references to x}$
+
+*p1 = 3; **p2 = 3; ***p3 = 3;				$\C{// change x}$
+  r1 = 3;    r2 = 3;      r3 = 3;			$\C{// change x}$
+**p3 = &y; *p3 = &z;						$\C{// change p1, p2}$
+&&r3 = &y; &r3 = &z;						$\C{// change p1, p2}$
+int & ar[3] = {x, y, z};					$\C{// initialize array of references}$
+
+typeof( ar[1]) p;							$\C{// is int, referenced object type}$
+typeof(&ar[1]) q;							$\C{// is int \&, reference type}$
+sizeof( ar[1]) == sizeof(int);				$\C{// is true, referenced object size}$
+sizeof(&ar[1]) == sizeof(int *);			$\C{// is true, reference size}$
 \end{cfa}
 The important take away from this code example is that a reference offers a handle to an object, much like a pointer, but which is automatically dereferenced for convenience.
@@ -626,5 +630,5 @@
 \end{lrbox}
 \subfloat[3 States, internal variables]{\label{f:Coroutine3States}\usebox\myboxA}
-\qquad
+\qquad\qquad
 \subfloat[1 State, internal variables]{\label{f:Coroutine1State}\usebox\myboxB}
 \caption{\CFA Coroutine Fibonacci Implementations}
@@ -653,6 +657,5 @@
 
 \begin{figure}
-\centering
-\begin{cfa}
+\begin{cfa}[xleftmargin=4\parindentlnth]
 `coroutine` Format {
 	char ch;								$\C{// used for communication}$
Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision d046db2ac11262165d9c13d2f62d3fff987a4f36)
+++ doc/papers/general/Paper.tex	(revision 399a908cc97cdaad27d16bbf3d5672d0e4db6110)
@@ -1,3 +1,4 @@
-\documentclass[AMA,STIX1COL,STIXSMALL]{WileyNJD-v2}
+\documentclass[AMA,STIX1COL]{WileyNJD-v2}
+
 \articletype{RESEARCH ARTICLE}%
 
@@ -17,4 +18,5 @@
 \usepackage{upquote}						% switch curled `'" to straight
 \usepackage{listings}						% format program code
+\captionsetup{justification=raggedright,singlelinecheck=false}
 %\usepackage{enumitem}
 %\setlist[itemize]{topsep=3pt,itemsep=2pt,parsep=0pt}% global
@@ -27,6 +29,6 @@
 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
 
-\lefthyphenmin=4							% hyphen only after 4 characters
-\righthyphenmin=4
+\lefthyphenmin=3							% hyphen only after 4 characters
+\righthyphenmin=3
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -86,5 +88,5 @@
 \newcommand{\abbrevFont}{\textit}			% set empty for no italics
 \@ifundefined{eg}{
-\newcommand{\EG}{\abbrevFont{e}.\abbrevFont{g}.}
+\newcommand{\EG}{\abbrevFont{e}\abbrevFont{g}}
 \newcommand*{\eg}{%
 	\@ifnextchar{,}{\EG}%
@@ -93,5 +95,5 @@
 }}{}%
 \@ifundefined{ie}{
-\newcommand{\IE}{\abbrevFont{i}.\abbrevFont{e}.}
+\newcommand{\IE}{\abbrevFont{i}\abbrevFont{e}}
 \newcommand*{\ie}{%
 	\@ifnextchar{,}{\IE}%
@@ -129,13 +131,12 @@
 \lstdefinelanguage{CFA}[ANSI]{C}{
 	morekeywords={
-		_Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, _At, __attribute,
-		__attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
-		__const, __const__, disable, dtype, enable, exception, __extension__, fallthrough, fallthru,
-		finally, forall, ftype, _Generic, _Imaginary, inline, __label__, lvalue, _Noreturn, one_t,
-		otype, restrict, _Static_assert, throw, throwResume, trait, try, ttype, typeof, __typeof,
-		__typeof__, virtual, with, zero_t},
-	morekeywords=[2]{
-		_Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex, or,
-		resume, suspend, thread, _Thread_local, waitfor, when, yield},
+		_Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
+		auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
+		coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
+		__float80, float80, __float128, float128, forall, ftype, _Generic, _Imaginary, __imag, __imag__,
+		inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
+		otype, restrict, __restrict, __restrict__, __signed, __signed__, _Static_assert, thread,
+		_Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
+		virtual, __volatile, __volatile__, waitfor, when, with, zero_t},
 	moredirectives={defined,include_next}%
 }
@@ -158,5 +159,5 @@
 literate={-}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.1ex}}}}1 {^}{\raisebox{0.6ex}{$\scriptstyle\land\,$}}1
 	{~}{\raisebox{0.3ex}{$\scriptstyle\sim\,$}}1 % {`}{\ttfamily\upshape\hspace*{-0.1ex}`}1
-	{<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.5ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
+	{<-}{$\leftarrow$}2 {=>}{$\Rightarrow$}2 {->}{\makebox[1ex][c]{\raisebox{0.4ex}{\rule{0.8ex}{0.075ex}}}\kern-0.2ex{\textgreater}}2,
 moredelim=**[is][\color{red}]{`}{`},
 }% lstset
@@ -180,9 +181,9 @@
 \authormark{MOSS \textsc{et al}}
 
-\address[1]{\orgdiv{David R. Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Ontario}, \country{Canada}}}
-
-\corres{*Peter A. Buhr, \email{pabuhr{\char`\@}uwaterloo.ca}}
-\presentaddress{David R. Cheriton School of Computer Science, University of Waterloo, Waterloo, ON, N2L 3G1, Canada}
-
+\address[1]{\orgdiv{Cheriton School of Computer Science}, \orgname{University of Waterloo}, \orgaddress{\state{Waterloo, ON}, \country{Canada}}}
+
+\corres{*Peter A. Buhr, Cheriton School of Computer Science, University of Waterloo, 200 University Avenue West, Waterloo, ON, N2L 3G1, Canada. \email{pabuhr{\char`\@}uwaterloo.ca}}
+
+\fundingInfo{Natural Sciences and Engineering Research Council of Canada}
 
 \abstract[Summary]{
@@ -228,5 +229,5 @@
 Nevertheless, C, first standardized over thirty years ago, lacks many features that make programming in more modern languages safer and more productive.
 
-\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that aims to add modern language features to C while maintaining both source compatibility with C and a familiar programming model for programmers.
+\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that aims to add modern language features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
 The four key design goals for \CFA~\cite{Bilson03} are:
 (1) The behaviour of standard C code must remain the same when translated by a \CFA compiler as when translated by a C compiler;
@@ -328,6 +329,5 @@
 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array:
 \begin{cfa}
-void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
-					 int (* compar)( const void *, const void * ));
+void * bsearch( const void * key, const void * base, size_t nmemb, size_t size, int (* compar)( const void *, const void * ));
 int comp( const void * t1, const void * t2 ) {
 	 return *(double *)t1 < *(double *)t2 ? -1 : *(double *)t2 < *(double *)t1 ? 1 : 0;
@@ -336,5 +336,5 @@
 double * val = (double *)bsearch( &key, vals, 10, sizeof(vals[0]), comp ); $\C{// search sorted array}$
 \end{cfa}
-which can be augmented simply with a generalized, type-safe, \CFA-overloaded wrappers:
+which can be augmented simply with generalized, type-safe, \CFA-overloaded wrappers:
 \begin{cfa}
 forall( otype T | { int ?<?( T, T ); } ) T * bsearch( T key, const T * arr, size_t size ) {
@@ -398,5 +398,5 @@
 	T ?++( T * );
 };
-forall( otype T `| summable( T )` ) T sum( T a[$\,$], size_t size ) {  // use trait
+forall( otype T `| summable( T )` ) T sum( T a[$\,$], size_t size ) {$\C{// use trait}$
 	`T` total = { `0` };					$\C{// instantiate T from 0 by calling its constructor}$
 	for ( unsigned int i = 0; i < size; i += 1 ) total `+=` a[i]; $\C{// select appropriate +}$
@@ -576,6 +576,6 @@
 	return (scalar(U)){ a.value + b.value };
 }
-scalar(metres) half_marathon = { 21093 };
-scalar(litres) swimming_pool = { 2500000 };
+scalar(metres) half_marathon = { 21_093 };
+scalar(litres) swimming_pool = { 2_500_000 };
 scalar(metres) marathon = half_marathon + half_marathon;
 scalar(litres) two_pools = swimming_pool + swimming_pool;
@@ -724,5 +724,5 @@
 \end{cfa}
 Here, the mass assignment sets all members of @s@ to zero.
-Since tuple-index expressions are a form of member-access expression, it is possible to use tuple-index expressions in conjunction with member tuple expressions to manually restructure a tuple (\eg rearrange, drop, and duplicate components).
+Since tuple-index expressions are a form of member-access expression, it is possible to use tuple-index expressions in conjunction with member-tuple expressions to manually restructure a tuple (\eg rearrange, drop, and duplicate components).
 \begin{cfa}
 [int, int, long, double] x;
@@ -1879,5 +1879,5 @@
 \lstDeleteShortInline@%
 \begin{tabular}{@{}l@{\hspace{3em}}l|l@{}}
-\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}	& \multicolumn{1}{c}{\textbf{C Implicit Hoisting}}	& \multicolumn{1}{|c}{\textbf{\CFA}}	\\
+\multicolumn{1}{c@{\hspace{3em}}}{\textbf{C Type Nesting}}	& \multicolumn{1}{c|}{\textbf{C Implicit Hoisting}}	& \multicolumn{1}{c}{\textbf{\CFA}}	\\
 \hline
 \begin{cfa}
@@ -2002,5 +2002,5 @@
 {
 	VLA  x,            y = { 20, 0x01 },     z = y;	$\C{// z points to y}$
-	//    ?{}( x );   ?{}( y, 20, 0x01 );    ?{}( z, y ); 
+	//      ?{}( x );   ?{}( y, 20, 0x01 );   ?{}( z, y ); 
 	^x{};									$\C{// deallocate x}$
 	x{};									$\C{// reallocate x}$
@@ -2027,7 +2027,8 @@
 These semantics closely mirror the rule for implicit declaration of constructors in \CC\cite[p.~186]{ANSI98:C++}.
 
-In some circumstance programmers may not wish to have constructor and destructor calls.
-In these cases, \CFA provides the initialization syntax \lstinline|S x @= {}|, and the object becomes unmanaged, so implicit constructor and destructor calls are not generated. 
-Any C initializer can be the right-hand side of an \lstinline|@=| initializer, \eg \lstinline|VLA a @= { 0, 0x0 }|, with the usual C initialization semantics. 
+In some circumstance programmers may not wish to have implicit constructor and destructor generation and calls.
+In these cases, \CFA provides the initialization syntax \lstinline|S x `@=` {}|, and the object becomes unmanaged, so implicit constructor and destructor calls are not generated. 
+Any C initializer can be the right-hand side of an \lstinline|@=| initializer, \eg \lstinline|VLA a @= { 0, 0x0 }|, with the usual C initialization semantics.
+The same syntax can be used in a compound literal, \eg \lstinline|a = VLA`@`{ 0, 0x0 }|, to create a C-style literal.
 The point of \lstinline|@=| is to provide a migration path from legacy C code to \CFA, by providing a mechanism to incrementally convert to implicit initialization.
 
@@ -2054,8 +2055,8 @@
 \begin{cfa}
 20_`hh`     // signed char
-21_`hh`u    // unsigned char
+21_`hh`u   // unsigned char
 22_`h`       // signed short int
 23_u`h`     // unsigned short int
-24`z`       // size_t
+24`z`         // size_t
 \end{cfa}
 &
@@ -2088,5 +2089,5 @@
 To provide this precision, \CFA introduces a new type @zero_t@ as the type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven);
 @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that C code involving @0@ continues to work. 
-With this addition, \CFA rewrites @if (x)@ and similar expressions to @if ((x) != 0)@ or the appropriate analogue, and any type @T@ is ``truthy'' by defining an operator overload @int ?!=?(T, zero_t)@.
+With this addition, \CFA rewrites @if (x)@ and similar expressions to @if ( (x) != 0 )@ or the appropriate analogue, and any type @T@ is ``truthy'' by defining an operator overload @int ?!=?( T, zero_t )@.
 \CC makes types truthy by adding a conversion to @bool@;
 prior to the addition of explicit cast operators in \CCeleven, this approach had the pitfall of making truthy types transitively convertable to any numeric type;
@@ -2163,6 +2164,6 @@
 \lstset{language=CFA,moredelim=**[is][\color{red}]{|}{|},deletedelim=**[is][]{`}{`}}
 \lstDeleteShortInline@%
-\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c@{\hspace{\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{\CC}}	\\
+\begin{tabular}{@{}l@{\hspace{2\parindentlnth}}l@{}}
+\multicolumn{1}{c@{\hspace{2\parindentlnth}}}{\textbf{\CFA}}	& \multicolumn{1}{c}{\textbf{\CC}}	\\
 \begin{cfa}
 struct W {
@@ -2260,7 +2261,5 @@
 \begin{cfa}
 MIN
-
 MAX
-
 PI
 E
@@ -2268,8 +2267,6 @@
 &
 \begin{cfa}
-SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN,
-		FLT_MIN, DBL_MIN, LDBL_MIN
-SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX,
-		FLT_MAX, DBL_MAX, LDBL_MAX
+SCHAR_MIN, CHAR_MIN, SHRT_MIN, INT_MIN, LONG_MIN, LLONG_MIN, FLT_MIN, DBL_MIN, LDBL_MIN
+SCHAR_MAX, UCHAR_MAX, SHRT_MAX, INT_MAX, LONG_MAX, LLONG_MAX, FLT_MAX, DBL_MAX, LDBL_MAX
 M_PI, M_PIl
 M_E, M_El
@@ -2444,6 +2441,6 @@
 ip = (int *)malloc( sizeof( int ) ); memset( ip, fill, dim * sizeof( int ) );
 ip = (int *)realloc( ip, 2 * dim * sizeof( int ) );
-ip = (int *)realloc( ip, 4 * dim * sizeof( int ) );
-			memset( ip, fill, 4 * dim * sizeof( int ) );
+ip = (int *)realloc( ip, 4 * dim * sizeof( int ) ); memset( ip, fill, 4 * dim * sizeof( int ) );
+
 ip = memalign( 16, sizeof( int ) );
 ip = memalign( 16, sizeof( int ) ); memset( ip, fill, sizeof( int ) );
