Diff [783152722192169260028e02eebed9a9a0c374a7:3f7e12cbec9518fa8ae8e76d3e2e6f7cd15d0d2a] for / – Cforall

.gitignore

r78315272	r3f7e12cb
52	52	tools/prettyprinter/pretty
53	53	tools/pretty
	54	tools/catchsig
	55	tools/repeat
54	56
55	57	# generated by xfig for user manual

configure

-              r78315272
+              r3f7e12cb
 ac_config_files="$ac_config_files Makefile src/driver/Makefile src/Makefile src/benchmark/Makefile src/examples/Makefile src/tests/Makefile src/tests/preempt_longrun/Makefile src/prelude/Makefile src/libcfa/Makefile tools/prettyprinter/Makefile"
+ac_config_files="$ac_config_files Makefile src/driver/Makefile src/Makefile src/benchmark/Makefile src/examples/Makefile src/tests/Makefile src/tests/preempt_longrun/Makefile src/prelude/Makefile src/libcfa/Makefile tools/Makefile tools/prettyprinter/Makefile"
 …
     "src/prelude/Makefile") CONFIG_FILES="$CONFIG_FILES src/prelude/Makefile" ;;
     "src/libcfa/Makefile") CONFIG_FILES="$CONFIG_FILES src/libcfa/Makefile" ;;
+    "tools/Makefile") CONFIG_FILES="$CONFIG_FILES tools/Makefile" ;;
     "tools/prettyprinter/Makefile") CONFIG_FILES="$CONFIG_FILES tools/prettyprinter/Makefile" ;;

configure.ac

r78315272	r3f7e12cb
238	238	src/prelude/Makefile
239	239	src/libcfa/Makefile
	240	tools/Makefile
240	241	tools/prettyprinter/Makefile
241	242	])

doc/LaTeXmacros/lstlang.sty

-              r78315272
+              r3f7e12cb
 %%
 %% Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 %%
 %% lstlang.sty --
 %%
+%%
+%% lstlang.sty --
+%%
 %% Author           : Peter A. Buhr
 %% Created On       : Sat May 13 16:34:42 2017
 …
                 __attribute__, auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__,
                 __const, __const__, disable, dtype, enable, __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, waitfor, when, with, zero_t},
+                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,
                 resume, suspend, thread, _Thread_local, yield},
+                _Atomic, coroutine, is_coroutine, is_monitor, is_thread, monitor, mutex, nomutex, or,
+                resume, suspend, thread, _Thread_local, waitfor, when, yield},
         moredirectives={defined,include_next}%
+}

doc/proposals/concurrency/.gitignore

r78315272	r3f7e12cb
16	16	build/*.out
17	17	build/*.ps
	18	build/*.pstex
	19	build/*.pstex_t
18	20	build/*.tex
19	21	build/*.toc

doc/proposals/concurrency/Makefile

-              r78315272
+              r3f7e12cb
 annex/glossary \
 text/intro \
+text/basics \
 text/cforall \
-text/basics \
 text/concurrency \
+text/internals \
 text/parallelism \
+text/results \
+text/together \
+text/future \
+}
 …
         ext_monitor \
         int_monitor \
+        dependency \
 }}
+PICTURES = ${addsuffix .pstex, \
+}
+PICTURES = ${addprefix build/, ${addsuffix .pstex, \
+        system \
+}}
 PROGRAMS = ${addsuffix .tex, \
 …
         build/*.out     \
         build/*.ps      \
+        build/*.pstex   \
         build/*.pstex_t \
         build/*.tex     \

doc/proposals/concurrency/annex/glossary.tex

-              r78315272
+              r3f7e12cb
+}
 \longnewglossaryentry{group-acquire}
 {name={bulk acquiring}}
+\longnewglossaryentry{bulk-acq}
+{name={bulk-acquiring}}
+{
 Implicitly acquiring several monitors when entering a monitor.
+}
+\longnewglossaryentry{multi-acq}
+{name={multiple-acquisition}}
+{
+Any locking technique which allow any single thread to acquire a lock multiple times.
+}
 …
 \newacronym{api}{API}{Application Program Interface}
 \newacronym{raii}{RAII}{Ressource Acquisition Is Initialization}
+\newacronym{numa}{NUMA}{Non-Uniform Memory Access}

doc/proposals/concurrency/figures/ext_monitor.fig

-              r78315272
+              r3f7e12cb
 1 -1 0 0 0 10 0.0000 2 105 90 6000 2160 d\001
 -6
 5850 1650 6150 1950
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 1800 105 105 6000 1800 6105 1905
 1 -1 0 0 0 10 0.0000 2 105 90 6000 1860 b\001
+5100 2100 5400 2400
+3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 2250 105 105 5250 2250 5355 2250
+1 -1 0 0 0 10 0.0000 2 105 120 5250 2295 X\001
 -6
 5100 1800 5400 2100
 …
 1 -1 0 0 0 10 0.0000 2 105 120 5250 2010 Y\001
 -6
 5100 2100 5400 2400
 3 0 1 -1 -1 1 0 4 0.000 1 0.0000 5250 2250 105 105 5250 2250 5355 2250
 1 -1 0 0 0 10 0.0000 2 105 120 5250 2295 X\001
+5850 1650 6150 1950
+3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6000 1800 105 105 6000 1800 6105 1905
+1 -1 0 0 0 10 0.0000 2 105 90 6000 1860 b\001
 -6
 3000 5400 7200 5700
+3070 5445 7275 5655
 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 3150 5550 80 80 3150 5550 3230 5630
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4500 5550 105 105 4500 5550 4605 5655
 …
 0 -1 0 0 0 12 0.0000 2 135 1035 4725 5625 blocked task\001
 0 -1 0 0 0 12 0.0000 2 135 870 3300 5625 active task\001
 0 -1 0 0 0 12 0.0000 2 180 930 6225 5625 routine ptrs\001
+0 -1 0 0 0 12 0.0000 2 135 1050 6225 5625 routine mask\001
 -6
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3300 3600 105 105 3300 3600 3405 3705
 …
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 2925 5475 2925 5475 3225 4050 3225 4050 2925
-1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 2
-2850 6075 3000
 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4
 3750 3750 3750 3750 4050 3150 4050
 …
 2 1 1 -1 -1 0 0 -1 4.000 0 0 0 0 0 5
 4200 5850 3300 4350 3300 4350 4200 5850 4200
-1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 3
-2850 5850 2850 5850 1650
-1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 0 0 4
-3150 3750 3150 3750 2850 5325 2850
 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 1 2
 1 1.00 60.00 120.00
 1 1.00 60.00 120.00
 3150 5250 2400
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
+3150 3750 3150 3750 2850 5850 2850 5850 1650
+1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
+2850 6150 3000
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 1800 5400 1800 5400 2400 5100 2400 5100 1800

doc/proposals/concurrency/style/cfa-format.tex

-              r78315272
+              r3f7e12cb
   belowskip=3pt,
   keepspaces=true,
+  tabsize=4,
   % frame=lines,
   literate=,
 …
   belowskip=3pt,
   keepspaces=true,
+  tabsize=4,
   % frame=lines,
   literate=,
 …
   keywordstyle=\bfseries\color{blue},
   keywordstyle=[2]\bfseries\color{Plum},
   commentstyle=\itshape\color{OliveGreen},                  % green and italic comments
+  commentstyle=\sf\itshape\color{OliveGreen},             % green and italic comments
   identifierstyle=\color{identifierCol},
   stringstyle=\sf\color{Mahogany},                                % use sanserif font
 …
   belowskip=3pt,
   keepspaces=true,
+  tabsize=4,
   % frame=lines,
   literate=,
 …
 }{}
+\lstnewenvironment{gocode}[1][]{
+  \lstset{
+    language = Golang,
+    style=defaultStyle,
+    #1
+  }
+}{}
 \newcommand{\zero}{\lstinline{zero_t}\xspace}
 \newcommand{\one}{\lstinline{one_t}\xspace}

doc/proposals/concurrency/text/basics.tex

-              r78315272
+              r3f7e12cb
 % ======================================================================
 % ======================================================================
 \chapter{Basics}\label{basics}
+\chapter{Concurrency Basics}\label{basics}
 % ======================================================================
 % ======================================================================
 Before any detailed discussion of the concurrency and parallelism in \CFA, it is important to describe the basics of concurrency and how they are expressed in \CFA user code.
+Before any detailed discussion of the concurrency and parallelism in \CFA, it is important to describe the basics of concurrency and how they are expressed in \CFA user-code.
 \section{Basics of concurrency}
+At its core, concurrency is based on having call-stacks and potentially multiple threads of execution for these stacks. Concurrency without parallelism only requires having multiple call stacks (or contexts) for a single thread of execution, and switching between these call stacks on a regular basis. A minimal concurrency product can be achieved by creating coroutines, which instead of context switching between each other, always ask an oracle where to context switch next. While coroutines do not technically require a stack, stackfull coroutines are the closest abstraction to a practical "naked"" call stack. When writing concurrency in terms of coroutines, the oracle effectively becomes a scheduler and the whole system now follows a cooperative threading-model \cit. The oracle/scheduler can either be a stackless or stackfull entity and correspondingly require one or two context switches to run a different coroutine. In any case, a subset of concurrency related challenges start to appear. For the complete set of concurrency challenges to occur, the only feature missing is preemption. Indeed, concurrency challenges appear with non-determinism. Guaranteeing mutual-exclusion or synchronisation are simply ways of limiting the lack of determinism in a system. A scheduler introduces order of execution uncertainty, while preemption introduces incertainty about where context-switches occur. Now it is important to understand that uncertainty is not necessarily undesireable; uncertainty can often be used by systems to significantly increase performance and is often the basis of giving a user the illusion that tasks are running in parallel. Optimal performance in concurrent applications is often obtained by having as much non-determinism as correctness allows\cit.
+At its core, concurrency is based on having multiple call-stacks and scheduling among threads of execution executing on these stacks. Concurrency without parallelism only requires having multiple call stacks (or contexts) for a single thread of execution.
+Execution with a single thread and multiple stacks where the thread is self-scheduling deterministically across the stacks is called coroutining. Execution with a single and multiple stacks but where the thread is scheduled by an oracle (non-deterministic from the thread perspective) across the stacks is called concurrency.
+Therefore, a minimal concurrency system can be achieved by creating coroutines, which instead of context switching among each other, always ask an oracle where to context switch next. While coroutines can execute on the caller's stack-frame, stackfull coroutines allow full generality and are sufficient as the basis for concurrency. The aforementioned oracle is a scheduler and the whole system now follows a cooperative threading-model \cit. The oracle/scheduler can either be a stackless or stackfull entity and correspondingly require one or two context switches to run a different coroutine. In any case, a subset of concurrency related challenges start to appear. For the complete set of concurrency challenges to occur, the only feature missing is preemption.
+A scheduler introduces order of execution uncertainty, while preemption introduces uncertainty about where context-switches occur. Mutual-exclusion and synchronisation are ways of limiting non-determinism in a concurrent system. Now it is important to understand that uncertainty is desireable; uncertainty can be used by runtime systems to significantly increase performance and is often the basis of giving a user the illusion that tasks are running in parallel. Optimal performance in concurrent applications is often obtained by having as much non-determinism as correctness allows\cit.
 \section{\protect\CFA 's Thread Building Blocks}
 One of the important features that is missing in C is threading. On modern architectures, a lack of threading is becoming less and less forgivable\cite{Sutter05, Sutter05b}, and therefore modern programming languages must have the proper tools to allow users to write performant concurrent and/or parallel programs. As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers used to imperative languages. And being a system-level language means programmers expect to choose precisely which features they need and which cost they are willing to pay.
+One of the important features that is missing in C is threading. On modern architectures, a lack of threading is unacceptable\cite{Sutter05, Sutter05b}, and therefore modern programming languages must have the proper tools to allow users to write performant concurrent programs to take advantage of parallelism. As an extension of C, \CFA needs to express these concepts in a way that is as natural as possible to programmers familiar with imperative languages. And being a system-level language means programmers expect to choose precisely which features they need and which cost they are willing to pay.
 \section{Coroutines: A stepping stone}\label{coroutine}
+While the main focus of this proposal is concurrency and parallelism, as mentionned above it is important to adress coroutines, which are actually a significant underlying aspect of a concurrency system. Indeed, while having nothing to do with parallelism and arguably little to do with concurrency, coroutines need to deal with context-switchs and other context-management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads, and a first class feature of \CFA. Furthermore, many design challenges of threads are at least partially present in designing coroutines, which makes the design effort that much more relevant. The core API of coroutines revolve around two features: independent call stacks and \code{suspend}/\code{resume}.
+Here is an example of a solution to the fibonnaci problem using \CFA coroutines:
+\begin{cfacode}
+        coroutine Fibonacci {
+              int fn; // used for communication
+        };
+        void ?{}(Fibonacci & this) { // constructor
+              this.fn = 0;
+        }
+        // main automacically called on first resume
+        void main(Fibonacci & this) {
+                int fn1, fn2;           // retained between resumes
+                this.fn = 0;
+                fn1 = this.fn;
+                suspend(this);          // return to last resume
+                this.fn = 1;
+While the main focus of this proposal is concurrency and parallelism, it is important to address coroutines, which are actually a significant building block of a concurrency system. Coroutines need to deal with context-switches and other context-management operations. Therefore, this proposal includes coroutines both as an intermediate step for the implementation of threads, and a first class feature of \CFA. Furthermore, many design challenges of threads are at least partially present in designing coroutines, which makes the design effort that much more relevant. The core \acrshort{api} of coroutines revolve around two features: independent call stacks and \code{suspend}/\code{resume}.
+\begin{figure}
+\begin{center}
+\begin{tabular}{c @{\hskip 0.025in}|@{\hskip 0.025in} c @{\hskip 0.025in}|@{\hskip 0.025in} c}
+\begin{ccode}[tabsize=2]
+//Using callbacks
+void fibonacci_func(
+        int n,
+        void (*callback)(int)
+) {
+        int first = 0;
+        int second = 1;
+        int next, i;
+        for(i = 0; i < n; i++)
+        {
+                if(i <= 1)
+                        next = i;
+                else {
+                        next = f1 + f2;
+                        f1 = f2;
+                        f2 = next;
+                }
+                callback(next);
+        }
+}
+int main() {
+        void print_fib(int n) {
+                printf("%d\n", n);
+        }
+        fibonacci_func(
+, print_fib
+        );
+}
+\end{ccode}&\begin{ccode}[tabsize=2]
+//Using output array
+void fibonacci_array(
+        int n,
+        int * array
+) {
+        int f1 = 0; int f2 = 1;
+        int next, i;
+        for(i = 0; i < n; i++)
+        {
+                if(i <= 1)
+                        next = i;
+                else {
+                        next = f1 + f2;
+                        f1 = f2;
+                        f2 = next;
+                }
+                array[i] = next;
+        }
+}
+int main() {
+        int a[10];
+        fibonacci_func(
+, a
+        );
+        for(int i=0;i<10;i++){
+                printf("%d\n", a[i]);
+        }
+}
+\end{ccode}&\begin{ccode}[tabsize=2]
+//Using external state
+typedef struct {
+        int f1, f2;
+} Iterator_t;
+int fibonacci_state(
+        Iterator_t * it
+) {
+        int f;
+        f = it->f1 + it->f2;
+        it->f2 = it->f1;
+        it->f1 = max(f,1);
+        return f;
+}
+int main() {
+        Iterator_t it={0,0};
+        for(int i=0;i<10;i++){
+                printf("%d\n",
+                        fibonacci_state(
+                                &it
+                        );
+                );
+        }
+}
+\end{ccode}
+\end{tabular}
+\end{center}
+\caption{Different implementations of a fibonacci sequence generator in C.}
+\label{lst:fibonacci-c}
+\end{figure}
+A good example of a problem made easier with coroutines is generators, like the fibonacci sequence. This problem comes with the challenge of decoupling how a sequence is generated and how it is used. Figure \ref{lst:fibonacci-c} shows conventional approaches to writing generators in C. All three of these approach suffer from strong coupling. The left and center approaches require that the generator have knowledge of how the sequence is used, while the rightmost approach requires holding internal state between calls on behalf of the generator and makes it much harder to handle corner cases like the Fibonacci seed.
+Figure \ref{lst:fibonacci-cfa} is an example of a solution to the fibonnaci problem using \CFA coroutines, where the coroutine stack holds sufficient state for the generation. This solution has the advantage of having very strong decoupling between how the sequence is generated and how it is used. Indeed, this version is as easy to use as the \code{fibonacci_state} solution, while the imlpementation is very similar to the \code{fibonacci_func} example.
+\begin{figure}
+\begin{cfacode}
+coroutine Fibonacci {
+        int fn; //used for communication
+};
+void ?{}(Fibonacci & this) { //constructor
+        this.fn = 0;
+}
+//main automacically called on first resume
+void main(Fibonacci & this) with (this) {
+        int fn1, fn2;           //retained between resumes
+        fn  = 0;
+        fn1 = fn;
+        suspend(this);          //return to last resume
+        fn  = 1;
+        fn2 = fn1;
+        fn1 = fn;
+        suspend(this);          //return to last resume
+        for ( ;; ) {
+                fn  = fn1 + fn2;
                 fn2 = fn1;
+                fn1 = this.fn;
+                suspend(this);          // return to last resume
+                for ( ;; ) {
+                        this.fn = fn1 + fn2;
+                        fn2 = fn1;
+                        fn1 = this.fn;
+                        suspend(this);  // return to last resume
+                fn1 = fn;
+                suspend(this);  //return to last resume
+        }
+}
+int next(Fibonacci & this) {
+        resume(this); //transfer to last suspend
+        return this.fn;
+}
+void main() { //regular program main
+        Fibonacci f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( f1 ) | next( f2 ) | endl;
+        }
+}
+\end{cfacode}
+\caption{Implementation of fibonacci using coroutines}
+\label{lst:fibonacci-cfa}
+\end{figure}
+Figure \ref{lst:fmt-line} shows the \code{Format} coroutine which rearranges text in order to group characters into blocks of fixed size. The example takes advantage of resuming coroutines in the constructor to simplify the code and highlights the idea that interesting control flow can occur in the constructor.
+\begin{figure}
+\begin{cfacode}[tabsize=3]
+//format characters into blocks of 4 and groups of 5 blocks per line
+coroutine Format {
+        char ch;                                                                        //used for communication
+        int g, b;                                                               //global because used in destructor
+};
+void  ?{}(Format & fmt) {
+        resume( fmt );                                                  //prime (start) coroutine
+}
+void ^?{}(Format & fmt) with fmt {
+        if ( fmt.g != 0 || fmt.b != 0 )
+        sout | endl;
+}
+void main(Format & fmt) with fmt {
+        for ( ;; ) {                                                    //for as many characters
+                for(g = 0; g < 5; g++) {                //groups of 5 blocks
+                        for(b = 0; b < 4; fb++) {       //blocks of 4 characters
+                                suspend();
+                                sout | ch;                                      //print character
+                        }
+                        sout | "  ";                                    //print block separator
+                }
+        }
+        int next(Fibonacci & this) {
+                resume(this); // transfer to last suspend
+                return this.fn;
+        }
+        void main() { // regular program main
+                Fibonacci f1, f2;
+                for ( int i = 1; i <= 10; i += 1 ) {
+                        sout | next( f1 ) | next( f2 ) | endl;
+                }
+        }
+\end{cfacode}
+                sout | endl;                                            //print group separator
+        }
+}
+void prt(Format & fmt, char ch) {
+        fmt.ch = ch;
+        resume(fmt);
+}
+int main() {
+        Format fmt;
+        char ch;
+        Eof: for ( ;; ) {                                               //read until end of file
+                sin | ch;                                                       //read one character
+                if(eof(sin)) break Eof;                 //eof ?
+                prt(fmt, ch);                                           //push character for formatting
+        }
+}
+\end{cfacode}
+\caption{Formatting text into lines of 5 blocks of 4 characters.}
+\label{lst:fmt-line}
+\end{figure}
 \subsection{Construction}
 One important design challenge for coroutines and threads (shown in section \ref{threads}) is that the runtime system needs to run code after the user-constructor runs. In the case of coroutines, this challenge is simpler since there is no non-determinism from preemption or scheduling. However, the underlying challenge remains the same for coroutines and threads.
 The runtime system needs to create the coroutine's stack and more importantly prepare it for the first resumption. The timing of the creation is non-trivial since users both expect to have fully constructed objects once execution enters the coroutine main and to be able to resume the coroutine from the constructor. Like for regular objects, constructors can still leak coroutines before they are ready. There are several solutions to this problem but the chosen options effectively forces the design of the coroutine.
+One important design challenge for coroutines and threads (shown in section \ref{threads}) is that the runtime system needs to run code after the user-constructor runs to connect the fully constructed object into the system. In the case of coroutines, this challenge is simpler since there is no non-determinism from preemption or scheduling. However, the underlying challenge remains the same for coroutines and threads.
+The runtime system needs to create the coroutine's stack and more importantly prepare it for the first resumption. The timing of the creation is non-trivial since users both expect to have fully constructed objects once execution enters the coroutine main and to be able to resume the coroutine from the constructor. As regular objects, constructors can leak coroutines before they are ready. There are several solutions to this problem but the chosen options effectively forces the design of the coroutine.
 Furthermore, \CFA faces an extra challenge as polymorphic routines create invisible thunks when casted to non-polymorphic routines and these thunks have function scope. For example, the following code, while looking benign, can run into undefined behaviour because of thunks:
 …
 forall(otype T)
 void noop(T *) {}
+void noop(T*) {}
 void bar() {
         int a;
+        async(noop, &a);
+}
+\end{cfacode}
+        async(noop, &a); //start thread running noop with argument a
+}
+\end{cfacode}
 The generated C code\footnote{Code trimmed down for brevity} creates a local thunk to hold type information:
 …
+}
 \end{ccode}
 The problem in this example is a race condition between the start of the execution of \code{noop} on the other thread and the stack frame of \code{bar} being destroyed. This extra challenge limits which solutions are viable because storing the function pointer for too long only increases the chances that the race will end in undefined behavior; i.e. the stack based thunk being destroyed before it was used. This challenge is an extension of challenges that come with second-class routines. Indeed, GCC nested routines also have the limitation that the routines cannot be passed outside of the scope of the functions these were declared in. The case of coroutines and threads is simply an extension of this problem to multiple call-stacks.
+The problem in this example is a storage management issue, the function pointer \code{_thunk0} is only valid until the end of the block, which limits the viable solutions because storing the function pointer for too long causes undefined behavior; i.e., the stack-based thunk being destroyed before it can be used. This challenge is an extension of challenges that come with second-class routines. Indeed, GCC nested routines also have the limitation that nested routine cannot be passed outside of the declaration scope. The case of coroutines and threads is simply an extension of this problem to multiple call-stacks.
 \subsection{Alternative: Composition}
+One solution to this challenge would be to use composition/containement,
+\begin{cfacode}
+        struct Fibonacci {
+              int fn; // used for communication
+              coroutine c; //composition
+        };
+        void ?{}(Fibonacci & this) {
+              this.fn = 0;
+                (this.c){};
+        }
+\end{cfacode}
+There are two downsides to this approach. The first, which is relatively minor, is that the base class needs to be made aware of the main routine pointer, regardless of whether a parameter or a virtual pointer is used, this means the coroutine data must be made larger to store a value that is actually a compile time constant (address of the main routine). The second problem, which is both subtle and significant, is that now users can get the initialisation order of there coroutines wrong. Indeed, every field of a \CFA struct is constructed but in declaration order, unless users explicitly write otherwise. This semantics means that users who forget to initialize a the coroutine may resume the coroutine with an uninitilized object. For coroutines, this is unlikely to be a problem, for threads however, this is a significant problem.
+One solution to this challenge is to use composition/containement, where coroutine fields are added to manage the coroutine.
+\begin{cfacode}
+struct Fibonacci {
+        int fn; //used for communication
+        coroutine c; //composition
+};
+void FibMain(void *) {
+        //...
+}
+void ?{}(Fibonacci & this) {
+        this.fn = 0;
+        //Call constructor to initialize coroutine
+        (this.c){myMain};
+}
+\end{cfacode}
+The downside of this approach is that users need to correctly construct the coroutine handle before using it. Like any other objects, doing so the users carefully choose construction order to prevent usage of unconstructed objects. However, in the case of coroutines, users must also pass to the coroutine information about the coroutine main, like in the previous example. This opens the door for user errors and requires extra runtime storage to pass at runtime information that can be known statically.
 \subsection{Alternative: Reserved keyword}
 …
 \begin{cfacode}
+        coroutine Fibonacci {
+              int fn; // used for communication
+        };
+\end{cfacode}
+This mean the compiler can solve problems by injecting code where needed. The downside of this approach is that it makes coroutine a special case in the language. Users who would want to extend coroutines or build their own for various reasons can only do so in ways offered by the language. Furthermore, implementing coroutines without language supports also displays the power of \CFA.
+While this is ultimately the option used for idiomatic \CFA code, coroutines and threads can both be constructed by users without using the language support. The reserved keywords are only present to improve ease of use for the common cases.
+coroutine Fibonacci {
+        int fn; //used for communication
+};
+\end{cfacode}
+The \code{coroutine} keyword means the compiler can find and inject code where needed. The downside of this approach is that it makes coroutine a special case in the language. Users wantint to extend coroutines or build their own for various reasons can only do so in ways offered by the language. Furthermore, implementing coroutines without language supports also displays the power of the programming language used. While this is ultimately the option used for idiomatic \CFA code, coroutines and threads can still be constructed by users without using the language support. The reserved keywords are only present to improve ease of use for the common cases.
 \subsection{Alternative: Lamda Objects}
 …
 Often, the canonical threading paradigm in languages is based on function pointers, pthread being one of the most well known examples. The main problem of this approach is that the thread usage is limited to a generic handle that must otherwise be wrapped in a custom type. Since the custom type is simple to write in \CFA and solves several issues, added support for routine/lambda based coroutines adds very little.
 A variation of this would be to use an simple function pointer in the same way pthread does for threads :
+A variation of this would be to use a simple function pointer in the same way pthread does for threads :
 \begin{cfacode}
 void foo( coroutine_t cid, void * arg ) {
 …
+}
 \end{cfacode}
 This semantic is more common for thread interfaces than coroutines but would work equally well. As discussed in section \ref{threads}, this approach is superseeded by static approaches in terms of expressivity.
+This semantics is more common for thread interfaces than coroutines works equally well. As discussed in section \ref{threads}, this approach is superseeded by static approaches in terms of expressivity.
 \subsection{Alternative: Trait-based coroutines}
 …
       coroutine_desc * get_coroutine(T & this);
 };
+\end{cfacode}
+This ensures an object is not a coroutine until \code{resume} (or \code{prime}) is called on the object. Correspondingly, any object that is passed to \code{resume} is a coroutine since it must satisfy the \code{is_coroutine} trait to compile. The advantage of this approach is that users can easily create different types of coroutines, for example, changing the memory foot print of a coroutine is trivial when implementing the \code{get_coroutine} routine. The \CFA keyword \code{coroutine} only has the effect of implementing the getter and forward declarations required for users to only have to implement the main routine.
+forall( dtype T | is_coroutine(T) ) void suspend(T &);
+forall( dtype T | is_coroutine(T) ) void resume (T &);
+\end{cfacode}
+This ensures an object is not a coroutine until \code{resume} is called on the object. Correspondingly, any object that is passed to \code{resume} is a coroutine since it must satisfy the \code{is_coroutine} trait to compile. The advantage of this approach is that users can easily create different types of coroutines, for example, changing the memory layout of a coroutine is trivial when implementing the \code{get_coroutine} routine. The \CFA keyword \code{coroutine} only has the effect of implementing the getter and forward declarations required for users to only have to implement the main routine.
 \begin{center}
 …
 \end{center}
 The combination of these two approaches allows users new to concurrency to have a easy and concise method while more advanced users can expose themselves to otherwise hidden pitfalls at the benefit of tighter control on memory layout and initialization.
+The combination of these two approaches allows users new to coroutinning and concurrency to have an easy and concise specification, while more advanced users have tighter control on memory layout and initialization.
 \section{Thread Interface}\label{threads}
 …
 \begin{cfacode}
         thread foo {};
+thread foo {};
 \end{cfacode}
 …
 \end{cfacode}
+Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), it is possible naturally extend the semantics using overloading to declare mains for different threads (the normal main being the main of the initial thread). As such the \code{main} routine of a thread can be defined as
+\begin{cfacode}
+        thread foo {};
+        void main(foo & this) {
+                sout | "Hello World!" | endl;
+        }
+\end{cfacode}
+In this example, threads of type \code{foo} start execution in the \code{void main(foo*)} routine which prints \code{"Hello World!"}. While this proposoal encourages this approach to enforce strongly-typed programming, users may prefer to use the routine based thread semantics for the sake of simplicity. With these semantics it is trivial to write a thread type that takes a function pointer as parameter and executes it on its stack asynchronously
+\begin{cfacode}
+        typedef void (*voidFunc)(void);
+        thread FuncRunner {
+                voidFunc func;
+        };
+        //ctor
+        void ?{}(FuncRunner & this, voidFunc inFunc) {
+                this.func = inFunc;
+        }
+        //main
+        void main(FuncRunner & this) {
+                this.func();
+        }
+\end{cfacode}
+An advantage of the overloading approach to main is to clearly highlight where and what memory is required to pass parameters and return values to/from a thread.
+Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is unnecessary. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} once the constructor has completed and \code{join} before the destructor runs.
+Obviously, for this thread implementation to be usefull it must run some user code. Several other threading interfaces use a function-pointer representation as the interface of threads (for example \Csharp~\cite{Csharp} and Scala~\cite{Scala}). However, this proposal considers that statically tying a \code{main} routine to a thread superseeds this approach. Since the \code{main} routine is already a special routine in \CFA (where the program begins), it is a natural extension of the semantics using overloading to declare mains for different threads (the normal main being the main of the initial thread). As such the \code{main} routine of a thread can be defined as
+\begin{cfacode}
+thread foo {};
+void main(foo & this) {
+        sout | "Hello World!" | endl;
+}
+\end{cfacode}
+In this example, threads of type \code{foo} start execution in the \code{void main(foo &)} routine, which prints \code{"Hello World!"}. While this thesis encourages this approach to enforce strongly-typed programming, users may prefer to use the routine-based thread semantics for the sake of simplicity. With the static semantics it is trivial to write a thread type that takes a function pointer as a parameter and executes it on its stack asynchronously.
+\begin{cfacode}
+typedef void (*voidFunc)(int);
+thread FuncRunner {
+        voidFunc func;
+        int arg;
+};
+void ?{}(FuncRunner & this, voidFunc inFunc, int arg) {
+        this.func = inFunc;
+        this.arg  = arg;
+}
+void main(FuncRunner & this) {
+        //thread starts here and runs the function
+        this.func( this.arg );
+}
+\end{cfacode}
+A consequence of the strongly-typed approach to main is that memory layout of parameters and return values to/from a thread are now explicitly specified in the \acrshort{api}.
+Of course for threads to be useful, it must be possible to start and stop threads and wait for them to complete execution. While using an \acrshort{api} such as \code{fork} and \code{join} is relatively common in the literature, such an interface is unnecessary. Indeed, the simplest approach is to use \acrshort{raii} principles and have threads \code{fork} after the constructor has completed and \code{join} before the destructor runs.
 \begin{cfacode}
 thread World;
 …
 \end{cfacode}
 This semantic has several advantages over explicit semantics typesafety is guaranteed, a thread is always started and stopped exaclty once and users cannot make any progamming errors. Another advantage of this semantic is that it naturally scale to multiple threads meaning basic synchronisation is very simple
+This semantic has several advantages over explicit semantics: a thread is always started and stopped exaclty once, users cannot make any progamming errors, and it naturally scales to multiple threads meaning basic synchronisation is very simple.
 \begin{cfacode}
 …
 \end{cfacode}
 However, one of the apparent drawbacks of this system is that threads now always form a lattice, that is they are always destroyed in opposite order of construction because of block structure. However, storage allocation is not limited to blocks; dynamic allocation can create threads that outlive the scope in which the thread is created much like dynamically allocating memory lets objects outlive the scope in which they are created
+However, one of the drawbacks of this approach is that threads now always form a lattice, that is they are always destroyed in the opposite order of construction because of block structure. This restriction is relaxed by using dynamic allocation, so threads can outlive the scope in which they are created, much like dynamically allocating memory lets objects outlive the scope in which they are created.
 \begin{cfacode}
 …
 };
-//main
 void main(MyThread & this) {
         //...
 …
         MyThread * long_lived;
+        {
+                //Start a thread at the beginning of the scope
                 MyThread short_lived;
-                //Start a thread at the beginning of the scope
-                DoStuff();
                 //create another thread that will outlive the thread in this scope
                 long_lived = new MyThread;
+                DoStuff();
                 //Wait for the thread short_lived to finish
+        }
         DoMoreStuff();
         //Now wait for the short_lived to finish
+        //Now wait for the long_lived to finish
         delete long_lived;
+}

doc/proposals/concurrency/text/cforall.tex

-              r78315272
+              r3f7e12cb
 % ======================================================================
 % ======================================================================
 \chapter{Cforall crash course}
+\chapter{Cforall Overview}
 % ======================================================================
 % ======================================================================
 As mentionned in the introduction, the document presents the design for the concurrency features in \CFA. Since it is a new language here is a quick review of the language specifically tailored to the features needed to support concurrency.
+The following is a quick introduction to the \CFA language, specifically tailored to the features needed to support concurrency.
+\CFA is a extension of ISO C and therefore supports much of the same paradigms as C. It is a non-object oriented system level language, meaning it has very most of the major abstractions have either no runtime cost or can be opt-out easily. Like C, the basics of \CFA revolve around structures and routines, which are thin abstractions over assembly. The vast majority of the code produced by a \CFA compiler respects memory-layouts and calling-conventions laid out by C. However, while \CFA is not an object-oriented language according to a strict definition. It does have some notion of objects, most importantly construction and destruction of objects. Most of the following pieces of code can be found as is on the \CFA website : \cite{www-cfa}
+\CFA is a 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 opt-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 (e.g., 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
+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{www-cfa}
 \section{References}
 Like \CC, \CFA introduces references as an alternative to pointers. In regards to concurrency, the semantics difference between pointers and references aren't particularly relevant but since this document uses mostly references here is a quick overview of the semantics :
+Like \CC, \CFA introduces rebindable references providing multiple dereferecing as an alternative to pointers. 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{cfacode}
 int x, *p1 = &x, **p2 = &p1, ***p3 = &p2,
+&r1 = x,    &&r2 = r1,   &&&r3 = r2;
+***p3 = 3;                                      // change x
+r3 = 3;                                         // change x, ***r3
+**p3 = ...;                                     // change p1
+&r3 = ...;                                      // change r1, (&*)**r3
+*p3 = ...;                                      // change p2
+&&r3 = ...;                                     // change r2, (&(&*)*)*r3
+&&&r3 = p3;                                     // change r3 to p3, (&(&(&*)*)*)r3
+int y, z, & ar[3] = { x, y, z };                // initialize array of references
+&ar[1] = &z;                                    // change reference array element
+typeof( ar[1] ) p;                              // is int, i.e., the type of referenced object
+typeof( &ar[1] ) q;                             // is int &, i.e., the type of reference
+sizeof( ar[1] ) == sizeof( int );               // is true, i.e., the size of referenced object
+sizeof( &ar[1] ) == sizeof( int *);             // is true, i.e., the size of a reference
+        &r1 = x,    &&r2 = r1,   &&&r3 = r2;
+***p3 = 3;                                                      //change x
+r3    = 3;                                                      //change x, ***r3
+**p3  = ...;                                            //change p1
+*p3   = ...;                                            //change p2
+int y, z, & ar[3] = {x, y, z};          //initialize array of references
+typeof( ar[1]) p;                                       //is int, i.e., the type of referenced object
+typeof(&ar[1]) q;                                       //is int &, i.e., the type of reference
+sizeof( ar[1]) == sizeof(int);          //is true, i.e., the size of referenced object
+sizeof(&ar[1]) == sizeof(int *);        //is true, i.e., the size of a reference
 \end{cfacode}
 The important thing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient.
+The important take away from this code example is that references offer a handle to an object, much like pointers, but which is automatically dereferenced for convinience.
 \section{Overloading}
 Another important feature \CFA has in common with \CC is function overloading :
+Another important feature of \CFA is function overloading as in Java and \CC, where routines with the same name are selected based on the number and type of the arguments. As well, \CFA uses the return type as part of the selection criteria, as in Ada\cite{Ada}. For routines with multiple parameters and returns, the selection is complex.
 \begin{cfacode}
 // selection based on type and number of parameters
 void f( void );                                 // (1)
 void f( char );                                 // (2)
 void f( int, double );                          // (3)
 f();                                            // select (1)
 f( 'a' );                                       // select (2)
 f( 3, 5.2 );                                    // select (3)
+//selection based on type and number of parameters
+void f(void);                   //(1)
+void f(char);                   //(2)
+void f(int, double);    //(3)
+f();                                    //select (1)
+f('a');                                 //select (2)
+f(3, 5.2);                              //select (3)
+// selection based on  type and number of returns
+char f( int );                                  // (1)
+double f( int );                                // (2)
+[ int, double ] f( int );                       // (3)
+char c = f( 3 );                                // select (1)
+double d = f( 4 );                              // select (2)
+[ int, double ] t = f( 5 );                     // select (3)
+//selection based on  type and number of returns
+char   f(int);                  //(1)
+double f(int);                  //(2)
+char   c = f(3);                //select (1)
+double d = f(4);                //select (2)
 \end{cfacode}
 This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced.
+This feature is particularly important for concurrency since the runtime system relies on creating different types to represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent name clashes. As seen in chapter \ref{basics}, routine \code{main} is an example that benefits from overloading.
 \section{Operators}
 Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation would be, like so :
+Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation occur, e.g.:
 \begin{cfacode}
 int ++?( int op );                              // unary prefix increment
 int ?++( int op );                              // unary postfix increment
 int ?+?( int op1, int op2 );                    // binary plus
 int ?<=?( int op1, int op2 );                   // binary less than
 int ?=?( int & op1, int op2 );                  // binary assignment
 int ?+=?( int & op1, int op2 );                 // binary plus-assignment
+int ++? (int op);                       //unary prefix increment
+int ?++ (int op);                       //unary postfix increment
+int ?+? (int op1, int op2);             //binary plus
+int ?<=?(int op1, int op2);             //binary less than
+int ?=? (int & op1, int op2);           //binary assignment
+int ?+=?(int & op1, int op2);           //binary plus-assignment
 struct S { int i, j; };
 S ?+?( S op1, S op2 ) {                         // add two structures
         return (S){ op1.i + op2.i, op1.j + op2.j };
+struct S {int i, j;};
+S ?+?(S op1, S op2) {                           //add two structures
+        return (S){op1.i + op2.i, op1.j + op2.j};
+}
 S s1 = { 1, 2 }, s2 = { 2, 3 }, s3;
 s3 = s1 + s2;                                   // compute sum: s3 == { 2, 5 }
+S s1 = {1, 2}, s2 = {2, 3}, s3;
+s3 = s1 + s2;                                           //compute sum: s3 == {2, 5}
 \end{cfacode}
+Since concurrency does not use operator overloading, this feature is more important as an introduction for the syntax of constructors.
+While concurrency does not use operator overloading directly, this feature is more important as an introduction for the syntax of constructors.
 \section{Constructors/Destructors}
 \CFA uses the following syntax for constructors and destructors :
+Object life-time is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object life-time as a mean of synchronization and/or mutual exclusion. Since \CFA relies heavily on the life time of objects, constructors and destructors are a core feature required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors :
 \begin{cfacode}
 struct S {
 …
         int * ia;
 };
 void ?{}( S & s, int asize ) with s {           // constructor operator
         size = asize;                           // initialize fields
         ia = calloc( size, sizeof( S ) );
+void ?{}(S & s, int asize) {    //constructor operator
+        s.size = asize;                         //initialize fields
+        s.ia = calloc(size, sizeof(S));
+}
 void ^?{}( S & s ) with s {                     // destructor operator
         free( ia );                             // de-initialization fields
+void ^?{}(S & s) {                              //destructor operator
+        free(ia);                                       //de-initialization fields
+}
 int main() {
         S x = { 10 }, y = { 100 };              // implict calls: ?{}( x, 10 ), ?{}( y, 100 )
         ...                                     // use x and y
         ^x{};  ^y{};                            // explicit calls to de-initialize
         x{ 20 };  y{ 200 };                     // explicit calls to reinitialize
         ...                                     // reuse x and y
 }                                               // implict calls: ^?{}( y ), ^?{}( x )
+        S x = {10}, y = {100};          //implict calls: ?{}(x, 10), ?{}(y, 100)
+        ...                                                     //use x and y
+        ^x{};  ^y{};                            //explicit calls to de-initialize
+        x{20};  y{200};                         //explicit calls to reinitialize
+        ...                                                     //reuse x and y
+}                                                               //implict calls: ^?{}(y), ^?{}(x)
 \end{cfacode}
+The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope.
+The language guarantees that every object and all their fields are constructed. Like \CC, construction of an object is automatically done on allocation and destruction of the object is done on deallocation. Allocation and deallocation can occur on the stack or on the heap.
+\begin{cfacode}
+{
+        struct S s = {10};      //allocation, call constructor
+        ...
+}                                               //deallocation, call destructor
+struct S * s = new();   //allocation, call constructor
+...
+delete(s);                              //deallocation, call destructor
+\end{cfacode}
+Note that like \CC, \CFA introduces \code{new} and \code{delete}, which behave like \code{malloc} and \code{free} in addition to constructing and destructing objects, after calling \code{malloc} and before calling \code{free} respectively.
+For more information see \cite{cforall-ug,rob-thesis,www-cfa}.
+\section{Parametric Polymorphism}
+Routines in \CFA can also be reused for multiple types. This capability is done using the \code{forall} clause which gives \CFA its name. \code{forall} clauses allow separately compiled routines to support generic usage over multiple types. For example, the following sum function works for any type that supports construction from 0 and addition :
+\begin{cfacode}
+//constraint type, 0 and +
+forall(otype T | { void ?{}(T *, zero_t); T ?+?(T, T); })
+T sum(T a[ ], size_t size) {
+        T total = 0;                            //construct T from 0
+        for(size_t i = 0; i < size; i++)
+                total = total + a[i];   //select appropriate +
+        return total;
+}
+S sa[5];
+int i = sum(sa, 5);                             //use S's 0 construction and +
+\end{cfacode}
+Since writing constraints on types can become cumbersome for more constrained functions, \CFA also has the concept of traits. Traits are named collection of constraints that can be used both instead and in addition to regular constraints:
+\begin{cfacode}
+trait sumable( otype T ) {
+        void ?{}(T *, zero_t);          //constructor from 0 literal
+        T ?+?(T, T);                            //assortment of additions
+        T ?+=?(T *, T);
+        T ++?(T *);
+        T ?++(T *);
+};
+forall( otype T | sumable(T) )  //use trait
+T sum(T a[], size_t size);
+\end{cfacode}
+\section{with Clause/Statement}
+Since \CFA lacks the concept of a receiver, certain functions end-up needing to repeat variable names often. To remove this inconvenience, \CFA provides the \code{with} statement, which opens an aggregate scope making its fields directly accessible (like Pascal).
+\begin{cfacode}
+struct S { int i, j; };
+int mem(S & this) with (this)           //with clause
+        i = 1;                                          //this->i
+        j = 2;                                          //this->j
+}
+int foo() {
+        struct S1 { ... } s1;
+        struct S2 { ... } s2;
+        with (s1)                                       //with statement
+        {
+                //access fields of s1
+                //without qualification
+                with (s2)                                       //nesting
+                {
+                        //access fields of s1 and s2
+                        //without qualification
+                }
+        }
+        with (s1, s2)                           //scopes open in parallel
+        {
+                //access fields of s1 and s2
+                //without qualification
+        }
+}
+\end{cfacode}
+For more information on \CFA see \cite{cforall-ug,rob-thesis,www-cfa}.

doc/proposals/concurrency/text/concurrency.tex

-              r78315272
+              r3f7e12cb
 % ======================================================================
 % ======================================================================
 Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
+Several tool can be used to solve concurrency challenges. Since many of these challenges appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms closely relate to networking concepts (channels\cite{CSP,Go} for example). However, in languages that use routine calls as their core abstraction-mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). This distinction in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. While this distinction can be hidden away in library code, effective use of the librairy still has to take both paradigms into account.
 Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and shared objects. At the lowest level, concurrent paradigms are implemented as atomic operations and locks. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}.
 An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for general purpose language, which is why it was rejected as the core paradigm for concurrency in \CFA.
 One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency-construct.
+An approach that is worth mentioning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to be the main concurrency paradigm for systems language, which is why it was rejected as the core paradigm for concurrency in \CFA.
+One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared-memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency-construct.
 \section{Basics}
 Non-determinism requires concurrent systems to offer support for mutual-exclusion and synchronisation. Mutual-exclusion is the concept that only a fixed number of threads can access a critical section at any given time, where a critical section is a group of instructions on an associated portion of data that requires the restricted access. On the other hand, synchronization enforces relative ordering of execution and synchronization tools numerous mechanisms to establish timing relationships among threads.
+Non-determinism requires concurrent systems to offer support for mutual-exclusion and synchronisation. Mutual-exclusion is the concept that only a fixed number of threads can access a critical section at any given time, where a critical section is a group of instructions on an associated portion of data that requires the restricted access. On the other hand, synchronization enforces relative ordering of execution and synchronization tools provide numerous mechanisms to establish timing relationships among threads.
 \subsection{Mutual-Exclusion}
 As mentionned above, mutual-exclusion is the guarantee that only a fix number of threads can enter a critical section at once. However, many solution exists for mutual exclusion which vary in terms of performance, flexibility and ease of use. Methods range from low-level locks, which are fast and flexible but require significant attention to be correct, to  higher-level mutual-exclusion methods, which sacrifice some performance in order to improve ease of use. Ease of use comes by either guaranteeing some problems cannot occur (e.g., being deadlock free) or by offering a more explicit coupling between data and corresponding critical section. For example, the \CC \code{std::atomic<T>} which offer an easy way to express mutual-exclusion on a restricted set of operations (.e.g: reading/writing large types atomically). Another challenge with low-level locks is composability. Locks are not composable because it takes careful organising for multiple locks to be used while preventing deadlocks. Easing composability is another feature higher-level mutual-exclusion mechanisms often offer.
+As mentionned above, mutual-exclusion is the guarantee that only a fix number of threads can enter a critical section at once. However, many solutions exist for mutual exclusion, which vary in terms of performance, flexibility and ease of use. Methods range from low-level locks, which are fast and flexible but require significant attention to be correct, to  higher-level mutual-exclusion methods, which sacrifice some performance in order to improve ease of use. Ease of use comes by either guaranteeing some problems cannot occur (e.g., being deadlock free) or by offering a more explicit coupling between data and corresponding critical section. For example, the \CC \code{std::atomic<T>} offers an easy way to express mutual-exclusion on a restricted set of operations (e.g.: reading/writing large types atomically). Another challenge with low-level locks is composability. Locks have restricted composability because it takes careful organising for multiple locks to be used while preventing deadlocks. Easing composability is another feature higher-level mutual-exclusion mechanisms often offer.
 \subsection{Synchronization}
 As for mutual-exclusion, low level synchronisation primitive often offer good performance and good flexibility at the cost of ease of use. Again, higher-level mechanism often simplify usage by adding better coupling between synchronization and data, .eg., message passing, or offering simple solution to otherwise involved challenges. An example of this is barging. As mentionned above synchronization can be expressed as guaranteeing that event \textit{X} always happens before \textit{Y}. Most of the time synchronisation happens around a critical section, where threads most acquire said critical section in a certain order. However, it may also be desired to be able to guarantee that event \textit{Z} does not occur between \textit{X} and \textit{Y}. This is called barging, where event \textit{X} tries to effect event \textit{Y} but anoter thread races to grab the critical section and emits \textit{Z} before \textit{Y}. Preventing or detecting barging is an involved challenge with low-level locks, which can be made much easier by higher-level constructs.
+As for mutual-exclusion, low-level synchronisation primitives often offer good performance and good flexibility at the cost of ease of use. Again, higher-level mechanism often simplify usage by adding better coupling between synchronization and data, e.g.: message passing, or offering simpler solution to otherwise involved challenges. As mentioned above, synchronization can be expressed as guaranteeing that event \textit{X} always happens before \textit{Y}. Most of the time, synchronisation happens within a critical section, where threads must acquire mutual-exclusion in a certain order. However, it may also be desirable to guarantee that event \textit{Z} does not occur between \textit{X} and \textit{Y}. Not satisfying this property called barging. For example, where event \textit{X} tries to effect event \textit{Y} but another thread acquires the critical section and emits \textit{Z} before \textit{Y}. The classic exmaple is the thread that finishes using a ressource and unblocks a thread waiting to use the resource, but the unblocked thread must compete again to acquire the resource. Preventing or detecting barging is an involved challenge with low-level locks, which can be made much easier by higher-level constructs. This challenge is often split into two different methods, barging avoidance and barging prevention. Algorithms that use status flags and other flag variables to detect barging threads are said to be using barging avoidance while algorithms that baton-passing locks between threads instead of releasing the locks are said to be using barging prevention.
 % ======================================================================
 …
 A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java~\cite{Java} or \uC~\cite{uC++book} but does not strictly require OO semantics. The only requirements is the ability to declare a handle to a shared object and a set of routines that act on it :
 \begin{cfacode}
         typedef /*some monitor type*/ monitor;
         int f(monitor & m);
         int main() {
                 monitor m;  //Handle m
                 f(m);       //Routine using handle
+        }
+typedef /*some monitor type*/ monitor;
+int f(monitor & m);
+int main() {
+        monitor m;  //Handle m
+        f(m);       //Routine using handle
+}
 \end{cfacode}
 …
 \begin{cfacode}
+        monitor counter_t { /*...see section $\ref{data}$...*/ };
+        void ?{}(counter_t & nomutex this); //constructor
+        size_t ++?(counter_t & mutex this); //increment
+        //need for mutex is platform dependent
+        void ?{}(size_t * this, counter_t & mutex cnt); //conversion
+\end{cfacode}
+Here, the constructor(\code{?\{\}}) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual-exclusion when constructing. This semantics is because an object not yet constructed should never be shared and therefore does not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} keyword depending on whether or not reading an \code{size_t} is an atomic operation.
+Having both \code{mutex} and \code{nomutex} keywords is redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without qualifiers \code{void foo(counter_t & this)}, then it is reasonable that it should default to the safest option \code{mutex}, whereas assuming \code{nomutex} is unsafe and may cause subtle errors. In fact, \code{nomutex} is the "normal" parameter behaviour, with the \code{nomutex} keyword effectively stating explicitly that "this routine is not special". Another alternative is to make having exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routines neither keyword. Mandatory keywords would also have the added benefit of being self-documented but at the cost of extra typing. While there are several benefits to mandatory keywords, they do bring a few challenges. Mandatory keywords in \CFA would imply that the compiler must know without a doubt wheter or not a parameter is a monitor or not. Since \CFA relies heavily on traits as an abstraction mechanism, the distinction between a type that is a monitor and a type that looks like a monitor can become blurred. For this reason, \CFA only has the \code{mutex} keyword.
+The next semantic decision is to establish when \code{mutex} may be used as a type qualifier. Consider the following declarations:
+\begin{cfacode}
+int f1(monitor & mutex m);
+int f2(const monitor & mutex m);
+int f3(monitor ** mutex m);
+int f4(monitor * mutex m []);
+int f5(graph(monitor*) & mutex m);
+\end{cfacode}
+The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed:
+\begin{cfacode}
+int f1(monitor & mutex m);   //Okay : recommanded case
+int f2(monitor * mutex m);   //Okay : could be an array but probably not
+int f3(monitor mutex m []);  //Not Okay : Array of unkown length
+int f4(monitor ** mutex m);  //Not Okay : Could be an array
+int f5(monitor * mutex m []); //Not Okay : Array of unkown length
+\end{cfacode}
+Unlike object-oriented monitors, where calling a mutex member \emph{implicitly} acquires mutual-exclusion, \CFA uses an explicit mechanism to acquire mutual-exclusion. A consequence of this approach is that it extends naturally to multi-monitor calls.
+\begin{cfacode}
+int f(MonitorA & mutex a, MonitorB & mutex b);
+MonitorA a;
+MonitorB b;
+f(a,b);
+\end{cfacode}
+The capacity to acquire multiple locks before entering a critical section is called \emph{\gls{group-acquire}}. In practice, writing multi-locking routines that do not lead to deadlocks is tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition is consistent across calls to routines using the same monitors as arguments. However, since \CFA monitors use multi-acquisition locks, users can effectively force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order:
+\begin{cfacode}
+        void foo(A & mutex a, B & mutex b) { //acquire a & b
+                ...
+        }
+        void bar(A & mutex a, B & /*nomutex*/ b) { //acquire a
+                ... foo(a, b); ... //acquire b
+        }
+        void baz(A & /*nomutex*/ a, B & mutex b) { //acquire b
+                ... foo(a, b); ... //acquire a
+        }
+\end{cfacode}
+The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
+However, such use leads the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires:
+\begin{enumerate}
+        \item Dynamically tracking of the monitor-call order.
+        \item Implement rollback semantics.
+\end{enumerate}
+While the first requirement is already a significant constraint on the system, implementing a general rollback semantics in a C-like language is prohibitively complex \cit. In \CFA, users simply need to be carefull when acquiring multiple monitors at the same time.
+Finally, for convenience, monitors support multiple acquiring, that is acquiring a monitor while already holding it does not cause a deadlock. It simply increments an internal counter which is then used to release the monitor after the number of acquires and releases match up. This is particularly usefull when monitor routines use other monitor routines as helpers or for recursions. For example:
+\begin{cfacode}
+monitor bank {
+        int money;
+        log_t usr_log;
+};
+void deposit( bank & mutex b, int deposit ) {
+        b.money += deposit;
+        b.usr_log | "Adding" | deposit | endl;
+}
+void transfer( bank & mutex mybank, bank & mutex yourbank, int me2you) {
+        deposit( mybank, -me2you );
+        deposit( yourbank, me2you );
+}
+\end{cfacode}
+% ======================================================================
+% ======================================================================
+\subsection{Data semantics} \label{data}
+% ======================================================================
+% ======================================================================
+Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contain shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appropriate protection. For example, here is a complete version of the counter showed in section \ref{call}:
+\begin{cfacode}
+monitor counter_t {
+        int value;
+};
+void ?{}(counter_t & this) {
+        this.cnt = 0;
+}
+int ?++(counter_t & mutex this) {
+        return ++this.value;
+}
+//need for mutex is platform dependent here
+void ?{}(int * this, counter_t & mutex cnt) {
+        *this = (int)cnt;
+}
+\end{cfacode}
+monitor counter_t { /*...see section $\ref{data}$...*/ };
+void ?{}(counter_t & nomutex this); //constructor
+size_t ++?(counter_t & mutex this); //increment
+//need for mutex is platform dependent
+void ?{}(size_t * this, counter_t & mutex cnt); //conversion
+\end{cfacode}
 This counter is used as follows:
 \begin{center}
 …
 \end{tabular}
 \end{center}
+Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting.
+% ======================================================================
+% ======================================================================
+\subsection{Implementation Details: Interaction with polymorphism}
+% ======================================================================
+% ======================================================================
+Depending on the choice of semantics for when monitor locks are acquired, interaction between monitors and \CFA's concept of polymorphism can be complex to support. However, it is shown that entry-point locking solves most of the issues.
+First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines.
+Before looking into complex control-flow, it is important to present the difference between the two acquiring options : callsite and entry-point locking, i.e. acquiring the monitors before making a mutex routine call or as the first operation of the mutex routine-call. For example:
+Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting, which is similar in usage to \CC \code{atomic} template.
+Here, the constructor(\code{?\{\}}) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual-exclusion when constructing. This semantics is because an object not yet con\-structed should never be shared and therefore does not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} keyword depending on whether or not reading a \code{size_t} is an atomic operation.
+For maximum usability, monitors use \gls{multi-acq} semantics, which means a single thread can acquire the same monitor multiple times without deadlock. For example, figure \ref{fig:search} uses recursion and \gls{multi-acq} to print values inside a binary tree.
+\begin{figure}
+\label{fig:search}
+\begin{cfacode}
+monitor printer { ... };
+struct tree {
+        tree * left, right;
+        char * value;
+};
+void print(printer & mutex p, char * v);
+void print(printer & mutex p, tree * t) {
+        print(p, t->value);
+        print(p, t->left );
+        print(p, t->right);
+}
+\end{cfacode}
+\caption{Recursive printing algorithm using \gls{multi-acq}.}
+\end{figure}
+Having both \code{mutex} and \code{nomutex} keywords is redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without qualifiers \code{void foo(counter_t & this)}, then it is reasonable that it should default to the safest option \code{mutex}, whereas assuming \code{nomutex} is unsafe and may cause subtle errors. In fact, \code{nomutex} is the ``normal'' parameter behaviour, with the \code{nomutex} keyword effectively stating explicitly that ``this routine is not special''. Another alternative is making exactly one of these keywords mandatory, which provides the same semantics but without the ambiguity of supporting routines with neither keyword. Mandatory keywords would also have the added benefit of being self-documented but at the cost of extra typing. While there are several benefits to mandatory keywords, they do bring a few challenges. Mandatory keywords in \CFA would imply that the compiler must know without doubt whether or not a parameter is a monitor or not. Since \CFA relies heavily on traits as an abstraction mechanism, the distinction between a type that is a monitor and a type that looks like a monitor can become blurred. For this reason, \CFA only has the \code{mutex} keyword and uses no keyword to mean \code{nomutex}.
+The next semantic decision is to establish when \code{mutex} may be used as a type qualifier. Consider the following declarations:
+\begin{cfacode}
+int f1(monitor & mutex m);
+int f2(const monitor & mutex m);
+int f3(monitor ** mutex m);
+int f4(monitor * mutex m []);
+int f5(graph(monitor*) & mutex m);
+\end{cfacode}
+The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C, and even then making sure objects are only acquired once becomes none-trivial. This problem can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To make the issue tractable, this project imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with at most one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. However, this ambiguity is part of the C type-system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed:
+\begin{cfacode}
+int f1(monitor & mutex m);   //Okay : recommanded case
+int f2(monitor * mutex m);   //Okay : could be an array but probably not
+int f3(monitor mutex m []);  //Not Okay : Array of unkown length
+int f4(monitor ** mutex m);  //Not Okay : Could be an array
+int f5(monitor * mutex m []); //Not Okay : Array of unkown length
+\end{cfacode}
+Note that not all array functions are actually distinct in the type system. However, even if the code generation could tell the difference, the extra information is still not sufficient to extend meaningfully the monitor call semantic.
+Unlike object-oriented monitors, where calling a mutex member \emph{implicitly} acquires mutual-exclusion of the receiver object, \CFA uses an explicit mechanism to acquire mutual-exclusion. A consequence of this approach is that it extends naturally to multi-monitor calls.
+\begin{cfacode}
+int f(MonitorA & mutex a, MonitorB & mutex b);
+MonitorA a;
+MonitorB b;
+f(a,b);
+\end{cfacode}
+While OO monitors could be extended with a mutex qualifier for multiple-monitor calls, no example of this feature could be found. The capacity to acquire multiple locks before entering a critical section is called \emph{\gls{bulk-acq}}. In practice, writing multi-locking routines that do not lead to deadlocks is tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition is consistent across calls to different routines using the same monitors as arguments. This consistent ordering means acquiring multiple monitors in the way is safe from deadlock. However, users can still force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order:
+\begin{cfacode}
+void foo(A & mutex a, B & mutex b) { //acquire a & b
+        ...
+}
+void bar(A & mutex a, B & /*nomutex*/ b) { //acquire a
+        ... foo(a, b); ... //acquire b
+}
+void baz(A & /*nomutex*/ a, B & mutex b) { //acquire b
+        ... foo(a, b); ... //acquire a
+}
+\end{cfacode}
+The \gls{multi-acq} monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order.
+However, such use leads to the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown\cit, solving this problem requires:
+\begin{enumerate}
+        \item Dynamically tracking of the monitor-call order.
+        \item Implement rollback semantics.
+\end{enumerate}
+While the first requirement is already a significant constraint on the system, implementing a general rollback semantics in a C-like language is prohibitively complex \cit. In \CFA, users simply need to be carefull when acquiring multiple monitors at the same time or only use \gls{bulk-acq} of all the monitors. While \CFA provides only a partial solution, many system provide no solution and the \CFA partial solution handles many useful cases.
+For example, \gls{multi-acq} and \gls{bulk-acq} can be used together in interesting ways:
+\begin{cfacode}
+monitor bank { ... };
+void deposit( bank & mutex b, int deposit );
+void transfer( bank & mutex mybank, bank & mutex yourbank, int me2you) {
+        deposit( mybank, -me2you );
+        deposit( yourbank, me2you );
+}
+\end{cfacode}
+This example shows a trivial solution to the bank-account transfer-problem\cit. Without \gls{multi-acq} and \gls{bulk-acq}, the solution to this problem is much more involved and requires carefull engineering.
+\subsection{\code{mutex} statement} \label{mutex-stmt}
+The call semantics discussed aboved have one software engineering issue, only a named routine can acquire the mutual-exclusion of a set of monitor. \CFA offers the \code{mutex} statement to workaround the need for unnecessary names, avoiding a major software engineering problem\cit. Listing \ref{lst:mutex-stmt} shows an example of the \code{mutex} statement, which introduces a new scope in which the mutual-exclusion of a set of monitor is acquired. Beyond naming, the \code{mutex} statement has no semantic difference from a routine call with \code{mutex} parameters.
+\begin{figure}
 \begin{center}
+\setlength\tabcolsep{1.5pt}
+\begin{tabular}{|c|c|c|}
+Code & \gls{callsite-locking} & \gls{entry-point-locking} \\
+\CFA & pseudo-code & pseudo-code \\
+\begin{tabular}{|c|c|}
+function call & \code{mutex} statement \\
 \hline
 \begin{cfacode}[tabsize=3]
+void foo(monitor& mutex a){
+        //Do Work
+        //...
+}
+void main() {
+        monitor a;
+        foo(a);
+}
+\end{cfacode} & \begin{pseudo}[tabsize=3]
+foo(& a) {
+        //Do Work
+        //...
+}
+main() {
+        monitor a;
+        //calling routine
+        //handles concurrency
+        acquire(a);
+        foo(a);
+        release(a);
+}
+\end{pseudo} & \begin{pseudo}[tabsize=3]
+foo(& a) {
+        //called routine
+        //handles concurrency
+        acquire(a);
+        //Do Work
+        //...
+        release(a);
+}
+main() {
+        monitor a;
+        foo(a);
+}
+\end{pseudo}
+monitor M {};
+void foo( M & mutex m ) {
+        //critical section
+}
+void bar( M & m ) {
+        foo( m );
+}
+\end{cfacode}&\begin{cfacode}[tabsize=3]
+monitor M {};
+void bar( M & m ) {
+        mutex(m) {
+                //critical section
+        }
+}
+\end{cfacode}
 \end{tabular}
 \end{center}
+\Gls{callsite-locking} is inefficient, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else.
+Note the \code{mutex} keyword relies on the resolver, which means that in cases where a generic monitor routine is actually desired, writing a mutex routine is possible with the proper trait. This is possible because monitors are designed in terms a trait. For example:
+\begin{cfacode}
+//Incorrect
+//T is not a monitor
+forall(dtype T)
+void foo(T * mutex t);
+//Correct
+//this function only works on monitors
+//(any monitor)
+forall(dtype T | is_monitor(T))
+void bar(T * mutex t));
+\end{cfacode}
+% ======================================================================
+% ======================================================================
+\section{Internal scheduling} \label{insched}
+% ======================================================================
+% ======================================================================
+In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this is generally achieved with internal or external scheduling as in\cit. Since internal scheduling of single monitors is mostly a solved problem, this proposal concentraits on extending internal scheduling to multiple monitors at once. Indeed, like the \gls{group-acquire} semantics, internal scheduling extends to multiple monitors at once in a way that is natural to the user but requires additional complexity on the implementation side.
+\caption{Regular call semantics vs. \code{mutex} statement}
+\label{lst:mutex-stmt}
+\end{figure}
+% ======================================================================
+% ======================================================================
+\subsection{Data semantics} \label{data}
+% ======================================================================
+% ======================================================================
+Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contain shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appropriate protection. For example, here is a complete version of the counter showed in section \ref{call}:
+\begin{cfacode}
+monitor counter_t {
+        int value;
+};
+void ?{}(counter_t & this) {
+        this.cnt = 0;
+}
+int ?++(counter_t & mutex this) {
+        return ++this.value;
+}
+//need for mutex is platform dependent here
+void ?{}(int * this, counter_t & mutex cnt) {
+        *this = (int)cnt;
+}
+\end{cfacode}
+Like threads and coroutines, monitors are defined in terms of traits with some additional language support in the form of the \code{monitor} keyword. The monitor trait is :
+\begin{cfacode}
+trait is_monitor(dtype T) {
+        monitor_desc * get_monitor( T & );
+        void ^?{}( T & mutex );
+};
+\end{cfacode}
+Note that the destructor of a monitor must be a \code{mutex} routine. This requirement ensures that the destructor has mutual-exclusion. As with any object, any call to a monitor, using \code{mutex} or otherwise, is Undefined Behaviour after the destructor has run.
+% ======================================================================
+% ======================================================================
+\section{Internal scheduling} \label{intsched}
+% ======================================================================
+% ======================================================================
+In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this capability is generally achieved with internal or external scheduling as in\cit. Since internal scheduling within a single monitor is mostly a solved problem, this thesis concentrates on extending internal scheduling to multiple monitors. Indeed, like the \gls{bulk-acq} semantics, internal scheduling extends to multiple monitors in a way that is natural to the user but requires additional complexity on the implementation side.
 First, here is a simple example of such a technique:
 \begin{cfacode}
         monitor A {
                 condition e;
+        }
         void foo(A & mutex a) {
                 ...
                 // Wait for cooperation from bar()
                 wait(a.e);
                 ...
+        }
         void bar(A & mutex a) {
                 // Provide cooperation for foo()
                 ...
                 // Unblock foo at scope exit
                 signal(a.e);
+        }
 \end{cfacode}
 There are two details to note here. First, there \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This is needed to respect mutual-exclusion. Second, in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
 An important aspect to take into account here is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, foo is guaranteed to resume immediately after (unless some other thread waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding barging prevention or barging avoidance is more involved without language support. Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
+monitor A {
+        condition e;
+}
+void foo(A & mutex a) {
+        ...
+        //Wait for cooperation from bar()
+        wait(a.e);
+        ...
+}
+void bar(A & mutex a) {
+        //Provide cooperation for foo()
+        ...
+        //Unblock foo
+        signal(a.e);
+}
+\end{cfacode}
+There are two details to note here. First, the \code{signal} is a delayed operation, it only unblocks the waiting thread when it reaches the end of the critical section. This semantic is needed to respect mutual-exclusion. The alternative is to return immediately after the call to \code{signal}, which is significantly more restrictive. Second, in \CFA, while it is common to store a \code{condition} as a field of the monitor, a \code{condition} variable can be stored/created independently of a monitor. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering.
+An important aspect of the implementation is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, \code{foo} is guaranteed to resume immediately after (unless some other thread waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding barging prevention or barging avoidance is more involved without language support. Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
 % ======================================================================
 …
 % ======================================================================
 % ======================================================================
 It is easier to understand the problem of multi-monitor scheduling using a series of pseudo-code. Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors.
+It is easier to understand the problem of multi-monitor scheduling using a series of pseudo-code. Note that for simplicity in the following snippets of pseudo-code, waiting and signalling is done using an implicit condition variable, like Java built-in monitors. Indeed, \code{wait} statements always use the implicit condition as paremeter and explicitly names the monitors (A and B) associated with the condition. Note that in \CFA, condition variables are tied to a set of monitors on first use (called branding) which means that using internal scheduling with distinct sets of monitors requires one condition variable per set of monitors.
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
 The example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. There is an important thing to note here, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This restriction is hidden on the user side in \uC, as it is a logical requirement for barging prevention.
 A direct extension of the previous example is the \gls{group-acquire} version:
+The example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting (atomically blocking and releasing A) and the other acquires before signalling. It is important to note here that both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This semantic is a logical requirement for barging prevention.
+A direct extension of the previous example is a \gls{bulk-acq} version:
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
+This version uses \gls{group-acquire} (denoted using the \& symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization happens between the two threads in exactly the same way and order. The only difference is that mutual exclusion covers more monitors. On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
+While deadlock issues can occur when nesting monitors, these issues are only a symptom of the fact that locks, and by extension monitors, are not perfectly composable. However, for monitors as for locks, it is possible to write a program using nesting without encountering any problems if nested is done correctly. For example, the next pseudo-code snippet acquires monitors A then B before waiting while only acquiring B when signalling, effectively avoiding the nested monitor problem.
+This version uses \gls{bulk-acq} (denoted using the {\sf\&} symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization happens between the two threads in exactly the same way and order. The only difference is that mutual exclusion covers more monitors. On the implementation side, handling multiple monitors does add a degree of complexity as the next few examples demonstrate.
+While deadlock issues can occur when nesting monitors, these issues are only a symptom of the fact that locks, and by extension monitors, are not perfectly composable. For monitors, a well known deadlock problem is the Nested Monitor Problem\cit, which occurs when a \code{wait} is made by a thread that holds more than one monitor. For example, the following pseudo-code runs into the nested-monitor problem :
 \begin{multicols}{2}
 \begin{pseudo}
 …
 \begin{pseudo}
+acquire A
+        acquire B
+                signal B
+        release B
+release A
+\end{pseudo}
+\end{multicols}
+The \code{wait} only releases monitor \code{B} so the signalling thread cannot acquire monitor \code{A} to get to the \code{signal}. Attempting release of all acquired monitors at the \code{wait} results in another set of problems such as releasing monitor \code{C}, which has nothing to do with the \code{signal}.
+However, for monitors as for locks, it is possible to write a program using nesting without encountering any problems if nesting is done correctly. For example, the next pseudo-code snippet acquires monitors {\sf A} then {\sf B} before waiting, while only acquiring {\sf B} when signalling, effectively avoiding the nested monitor problem.
+\begin{multicols}{2}
+\begin{pseudo}
+acquire A
+        acquire B
+                wait B
+        release B
+release A
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
 acquire B
 …
 \end{multicols}
+The next example is where \gls{group-acquire} adds a significant layer of complexity to the internal signalling semantics.
+% ======================================================================
+% ======================================================================
+\subsection{Internal Scheduling - in depth}
+% ======================================================================
+% ======================================================================
+A larger example is presented to show complex issuesfor \gls{bulk-acq} and all the implementation options are analyzed. Listing \ref{lst:int-bulk-pseudo} shows an example where \gls{bulk-acq} adds a significant layer of complexity to the internal signalling semantics, and listing \ref{lst:int-bulk-cfa} shows the corresponding \CFA code which implements the pseudo-code in listing \ref{lst:int-bulk-pseudo}. For the purpose of translating the given pseudo-code into \CFA-code any method of introducing monitor into context, other than a \code{mutex} parameter, is acceptable, e.g., global variables, pointer parameters or using locals with the \code{mutex}-statement.
+\begin{figure}[!b]
 \begin{multicols}{2}
 Waiting thread
 \begin{pseudo}[numbers=left]
 acquire A
         // Code Section 1
+        //Code Section 1
         acquire A & B
                 // Code Section 2
+                //Code Section 2
                 wait A & B
                 // Code Section 3
+                //Code Section 3
         release A & B
         // Code Section 4
+        //Code Section 4
 release A
 \end{pseudo}
 …
 \begin{pseudo}[numbers=left, firstnumber=10]
 acquire A
         // Code Section 5
+        //Code Section 5
         acquire A & B
                 // Code Section 6
+                //Code Section 6
                 signal A & B
                 // Code Section 7
+                //Code Section 7
         release A & B
         // Code Section 8
+        //Code Section 8
 release A
 \end{pseudo}
 \end{multicols}
+\caption{Internal scheduling with \gls{bulk-acq}}
+\label{lst:int-bulk-pseudo}
+\end{figure}
+\begin{figure}[!b]
 \begin{center}
+Listing 1
+\begin{cfacode}[xleftmargin=.4\textwidth]
+monitor A a;
+monitor B b;
+condition c;
+\end{cfacode}
 \end{center}
+It is particularly important to pay attention to code sections 8 and 4, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B" (line 16), it must actually transfer ownership of monitor B to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs the monitor A, simply waking up the waiting thread is not an option because it would violate mutual exclusion. There are three options:
+\begin{multicols}{2}
+Waiting thread
+\begin{cfacode}
+mutex(a) {
+        //Code Section 1
+        mutex(a, b) {
+                //Code Section 2
+                wait(c);
+                //Code Section 3
+        }
+        //Code Section 4
+}
+\end{cfacode}
+\columnbreak
+Signalling thread
+\begin{cfacode}
+mutex(a) {
+        //Code Section 5
+        mutex(a, b) {
+                //Code Section 6
+                signal(c);
+                //Code Section 7
+        }
+        //Code Section 8
+}
+\end{cfacode}
+\end{multicols}
+\caption{Equivalent \CFA code for listing \ref{lst:int-bulk-pseudo}}
+\label{lst:int-bulk-cfa}
+\end{figure}
+The complexity begins at code sections 4 and 8, which are where the existing semantics of internal scheduling need to be extended for multiple monitors. The root of the problem is that \gls{bulk-acq} is used in a context where one of the monitors is already acquired and is why it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should ``release \code{A & B}'' (line 16), it must actually transfer ownership of monitor \code{B} to the waiting thread. This ownership trasnfer is required in order to prevent barging. Since the signalling thread still needs monitor \code{A}, simply waking up the waiting thread is not an option because it violates mutual exclusion. There are three options.
 \subsubsection{Delaying signals}
 The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed because this semantics fits most closely to the behaviour of single monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single group of object, effectively making the existing single monitor semantic viable by simply changing monitors to monitor collections.
+The obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is when the last lock is no longer needed because this semantics fits most closely to the behaviour of single-monitor scheduling. This solution has the main benefit of transferring ownership of groups of monitors, which simplifies the semantics from mutiple objects to a single group of objects, effectively making the existing single-monitor semantic viable by simply changing monitors to monitor groups.
 \begin{multicols}{2}
 Waiter
 …
 \end{pseudo}
 \end{multicols}
 However, this solution can become much more complicated depending on what is executed while secretly holding B (at line 10). Indeed, nothing prevents a user from signalling monitor A on a different condition variable:
 \newpage
 \begin{multicols}{2}
 Thread 1
+However, this solution can become much more complicated depending on what is executed while secretly holding B (at line 10). Indeed, nothing prevents signalling monitor A on a different condition variable:
+\begin{figure}
+\begin{multicols}{3}
+Thread $\alpha$
 \begin{pseudo}[numbers=left, firstnumber=1]
 acquire A
 …
 \end{pseudo}
-Thread 2
-\begin{pseudo}[numbers=left, firstnumber=6]
-acquire A
-        wait A
-release A
-\end{pseudo}
 \columnbreak
 Thread 3
 \begin{pseudo}[numbers=left, firstnumber=10]
+Thread $\gamma$
+\begin{pseudo}[numbers=left, firstnumber=1]
 acquire A
         acquire A & B
                 signal A & B
         release A & B
-        //Secretly keep B here
         signal A
 release A
+//Wakeup thread 1 or 2?
+//Who wakes up the other thread?
+\end{pseudo}
+\end{pseudo}
+\columnbreak
+Thread $\beta$
+\begin{pseudo}[numbers=left, firstnumber=1]
+acquire A
+        wait A
+release A
+\end{pseudo}
 \end{multicols}
+\caption{Dependency graph}
+\label{lst:dependency}
+\end{figure}
 The goal in this solution is to avoid the need to transfer ownership of a subset of the condition monitors. However, this goal is unreacheable in the previous example. Depending on the order of signals (line 12 and 15) two cases can happen.
 …
 Note that ordering is not determined by a race condition but by whether signalled threads are enqueued in FIFO or FILO order. However, regardless of the answer, users can move line 15 before line 11 and get the reverse effect.
 In both cases, the threads need to be able to distinguish on a per monitor basis which ones need to be released and which ones need to be transferred. Which means monitors cannot be handled as a single homogenous group.
+In both cases, the threads need to be able to distinguish, on a per monitor basis, which ones need to be released and which ones need to be transferred, which means monitors cannot be handled as a single homogenous group and therefore effectively precludes this approach.
 \subsubsection{Dependency graphs}
 In the Listing 1 pseudo-code, there is a solution which statisfies both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example, the following code, which is just a direct extension to three monitors, requires at least three ownership transfer and has multiple solutions:
+In the listing \ref{lst:int-bulk-pseudo} pseudo-code, there is a solution which statisfies both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases \code{A & B} and then the waiter transfers back ownership of \code{A} when it releases it, then the problem is solved (\code{B} is no longer in use at this point). Dynamically finding the correct order is therefore the second possible solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example, the following code, which is just a direct extension to three monitors, requires at least three ownership transfer and has multiple solutions:
 \begin{multicols}{2}
 …
 \end{pseudo}
 \end{multicols}
+Resolving dependency graph being a complex and expensive endeavour, this solution is not the preffered one.
+\begin{figure}
+\begin{center}
+\input{dependency}
+\end{center}
+\caption{Dependency graph of the statements in listing \ref{lst:dependency}}
+\label{fig:dependency}
+\end{figure}
+Listing \ref{lst:dependency} is the three thread example rewritten for dependency graphs. Figure \ref{fig:dependency} shows the corresponding dependency graph that results, where every node is a statement of one of the three threads, and the arrows the dependency of that statement (e.g., $\alpha1$ must happen before $\alpha2$). The extra challenge is that this dependency graph is effectively post-mortem, but the runtime system needs to be able to build and solve these graphs as the dependency unfolds. Resolving dependency graph being a complex and expensive endeavour, this solution is not the preffered one.
 \subsubsection{Partial signalling} \label{partial-sig}
+Finally, the solution that is chosen for \CFA is to use partial signalling. Consider the following case:
+\begin{multicols}{2}
+\begin{pseudo}[numbers=left]
+acquire A
+        acquire A & B
+                wait A & B
+        release A & B
+release A
+\end{pseudo}
+\columnbreak
+\begin{pseudo}[numbers=left, firstnumber=6]
+acquire A
+        acquire A & B
+                signal A & B
+        release A & B
+        // ... More code
+release A
+\end{pseudo}
+\end{multicols}
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated into only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
+Finally, the solution that is chosen for \CFA is to use partial signalling. Again using listing \ref{lst:int-bulk-pseudo}, the partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated into only two actions, passing monitors to the next owner when they should be release and conditionally waking threads if all conditions are met. This solution has a much simpler implementation than a dependency graph solving algorithm which is why it was chosen. Furthermore, after being fully implemented, this solution does not appear to have any downsides worth mentionning.
 % ======================================================================
 …
 % ======================================================================
 % ======================================================================
+An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation, which is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
+For example here is an example highlighting the difference in behaviour:
+\begin{center}
+\begin{figure}
 \begin{tabular}{|c|c|}
 \code{signal} & \code{signal_block} \\
 \hline
+\begin{cfacode}
+monitor M { int val; };
+void foo(M & mutex m ) {
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+        wait( c );
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+}
+void bar(M & mutex m ) {
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+        signal( c );
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+}
+\end{cfacode}&\begin{cfacode}
+monitor M { int val; };
+void foo(M & mutex m ) {
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+        wait( c );
+        m.val++;
+        sout| "Foo:" | m.val |endl;
+}
+void bar(M & mutex m ) {
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+        signal_block( c );
+        m.val++;
+        sout| "Bar:" | m.val |endl;
+\begin{cfacode}[tabsize=3]
+monitor DatingService
+{
+        //compatibility codes
+        enum{ CCodes = 20 };
+        int girlPhoneNo
+        int boyPhoneNo;
+};
+condition girls[CCodes];
+condition boys [CCodes];
+condition exchange;
+int girl(int phoneNo, int ccode)
+{
+        //no compatible boy ?
+        if(empty(boys[ccode]))
+        {
+                //wait for boy
+                wait(girls[ccode]);
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy from chair
+                signal(exchange);
+        }
+        else
+        {
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy
+                signal(boys[ccode]);
+                //sit in chair
+                wait(exchange);
+        }
+        return boyPhoneNo;
+}
+int boy(int phoneNo, int ccode)
+{
+        //same as above
+        //with boy/girl interchanged
+}
+\end{cfacode}&\begin{cfacode}[tabsize=3]
+monitor DatingService
+{
+        //compatibility codes
+        enum{ CCodes = 20 };
+        int girlPhoneNo;
+        int boyPhoneNo;
+};
+condition girls[CCodes];
+condition boys [CCodes];
+//exchange is not needed
+int girl(int phoneNo, int ccode)
+{
+        //no compatible boy ?
+        if(empty(boys[ccode]))
+        {
+                //wait for boy
+                wait(girls[ccode]);
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy from chair
+                signal(exchange);
+        }
+        else
+        {
+                //make phone number available
+                girlPhoneNo = phoneNo;
+                //wake boy
+                signal_block(boys[ccode]);
+                //second handshake unnecessary
+        }
+        return boyPhoneNo;
+}
+int boy(int phoneNo, int ccode)
+{
+        //same as above
+        //with boy/girl interchanged
+}
 \end{cfacode}
 \end{tabular}
+\end{center}
+Assuming that \code{val} is initialized at 0, that each routine are called from seperate thread and that \code{foo} is always called first. The previous code would yield the following output:
+\caption{Dating service example using \code{signal} and \code{signal_block}. }
+\label{lst:datingservice}
+\end{figure}
+An important note is that, until now, signalling a monitor was a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement. However, in some cases, it may be more convenient for users to immediately transfer ownership to the thread that is waiting for cooperation, which is achieved using the \code{signal_block} routine\footnote{name to be discussed}.
+The example in listing \ref{lst:datingservice} highlights the difference in behaviour. As mentioned, \code{signal} only transfers ownership once the current critical section exits, this behaviour requires additional synchronisation when a two-way handshake is needed. To avoid this extraneous synchronisation, the \code{condition} type offers the \code{signal_block} routine, which handles the two-way handshake as shown in the example. This removes the need for a second condition variables and simplifies programming. Like every other monitor semantic, \code{signal_block} uses barging prevention, which means mutual-exclusion is baton-passed both on the frond-end and the back-end of the call to \code{signal_block}, meaning no other thread can acquire the monitor neither before nor after the call.
+% ======================================================================
+% ======================================================================
+\section{External scheduling} \label{extsched}
+% ======================================================================
+% ======================================================================
+An alternative to internal scheduling is external scheduling, e.g., in \uC.
 \begin{center}
 \begin{tabular}{|c|c|}
 \code{signal} & \code{signal_block} \\
+\begin{tabular}{|c|c|c|}
+Internal Scheduling & External Scheduling & Go\\
 \hline
+\begin{pseudo}
+Foo: 0
+Bar: 1
+Bar: 2
+Foo: 3
+\end{pseudo}&\begin{pseudo}
+Foo: 0
+Bar: 1
+Foo: 2
+Bar: 3
+\end{pseudo}
+\end{tabular}
+\end{center}
+As mentionned, \code{signal} only transfers ownership once the current critical section exits, resulting in the second "Bar" line to be printed before the second "Foo" line. On the other hand, \code{signal_block} immediately transfers ownership to \code{bar}, causing an inversion of output. Obviously this means that \code{signal_block} is a blocking call, which will only be resumed once the signalled function exits the critical section.
+% ======================================================================
+% ======================================================================
+\subsection{Internal scheduling: Implementation} \label{inschedimpl}
+% ======================================================================
+% ======================================================================
+There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system.
+The main memory concern for concurrency is queues. All blocking operations are made by parking threads onto queues. These queues need to be intrinsic\cit to avoid the need memory allocation. This entails that all the fields needed to keep track of all needed information. Since internal scheduling can use an unbound amount of memory (depending on \gls{group-acquire}) statically defining information information in the intrusive fields of threads is insufficient. The only variable sized container that does not require memory allocation is the callstack, which is heavily used in the implementation of internal scheduling. Particularly the GCC extension variable length arrays which is used extensively.
+Since stack allocation is based around scope, the first step of the implementation is to identify the scopes that are available to store the information, and which of these can have a variable length. In the case of external scheduling, the threads and the condition both allow a fixed amount of memory to be stored, while mutex-routines and the actual blocking call allow for an unbound amount (though adding too much to the mutex routine stack size can become expansive faster).
+The following figure is the traditionnal illustration of a monitor :
+\begin{center}
+{\resizebox{0.4\textwidth}{!}{\input{monitor}}}
+\end{center}
+For \CFA, the previous picture does not have support for blocking multiple monitors on a single condition. To support \gls{group-acquire} two changes to this picture are required. First, it doesn't make sense to tie the condition to a single monitor since blocking two monitors as one would require arbitrarily picking a monitor to hold the condition. Secondly, the object waiting on the conditions and AS-stack cannot simply contain the waiting thread since a single thread can potentially wait on multiple monitors. As mentionned in section \ref{inschedimpl}, the handling in multiple monitors is done by partially passing, which entails that each concerned monitor needs to have a node object. However, for waiting on the condition, since all threads need to wait together, a single object needs to be queued in the condition. Moving out the condition and updating the node types yields :
+\begin{center}
+{\resizebox{0.8\textwidth}{!}{\input{int_monitor}}}
+\end{center}
+\newpage
+This picture and the proper entry and leave algorithms is the fundamental implementation of internal scheduling.
+\begin{multicols}{2}
+Entry
+\begin{pseudo}[numbers=left]
+if monitor is free
+        enter
+elif I already own the monitor
+        continue
+else
+        block
+increment recursion
+\end{pseudo}
+\columnbreak
+Exit
+\begin{pseudo}[numbers=left, firstnumber=8]
+decrement recursion
+if recursion == 0
+        if signal_stack not empty
+                set_owner to thread
+                if all monitors ready
+                        wake-up thread
+        if entry queue not empty
+                wake-up thread
+\end{pseudo}
+\end{multicols}
+Some important things to notice about the exit routine. The solution discussed in \ref{inschedimpl} can be seen on line 11 of the previous pseudo code. Basically, the solution boils down to having a seperate data structure for the condition queue and the AS-stack, and unconditionally transferring ownership of the monitors but only unblocking the thread when the last monitor has trasnferred ownership. This solution is safe as well as preventing any potential barging.
+% ======================================================================
+% ======================================================================
+\section{External scheduling} \label{extsched}
+% ======================================================================
+% ======================================================================
+An alternative to internal scheduling is to use external scheduling.
+\begin{center}
+\begin{tabular}{|c|c|}
+Internal Scheduling & External Scheduling \\
+\hline
+\begin{ucppcode}
+\begin{ucppcode}[tabsize=3]
 _Monitor Semaphore {
         condition c;
 …
 public:
         void P() {
+                if(inUse) wait(c);
+                if(inUse)
+                        wait(c);
                 inUse = true;
+        }
 …
+        }
+}
 \end{ucppcode}&\begin{ucppcode}
+\end{ucppcode}&\begin{ucppcode}[tabsize=3]
 _Monitor Semaphore {
 …
 public:
         void P() {
+                if(inUse) _Accept(V);
+                if(inUse)
+                        _Accept(V);
                 inUse = true;
+        }
 …
+        }
+}
+\end{ucppcode}
+\end{ucppcode}&\begin{gocode}[tabsize=3]
+type MySem struct {
+        inUse bool
+        c     chan bool
+}
+// acquire
+func (s MySem) P() {
+        if s.inUse {
+                select {
+                case <-s.c:
+                }
+        }
+        s.inUse = true
+}
+// release
+func (s MySem) V() {
+        s.inUse = false
+        //This actually deadlocks
+        //when single thread
+        s.c <- false
+}
+\end{gocode}
 \end{tabular}
 \end{center}
 This method is more constrained and explicit, which may help users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (e.g., \uC) or in terms of data (e.g. Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control-flow semantics were chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The previous example shows a simple use \code{_Accept} versus \code{wait}/\code{signal} and its advantages. Note that while other languages often use \code{accept} as the core external scheduling keyword, \CFA uses \code{waitfor} to prevent name collisions with existing socket APIs.
 In the case of internal scheduling, the call to \code{wait} only guarantees that \code{V} is the last routine to access the monitor. This entails that the routine \code{V} may have acquired mutual exclusion several times while routine \code{P} was waiting. On the other hand, external scheduling guarantees that while routine \code{P} was waiting, no routine other than \code{V} could acquire the monitor.
+This method is more constrained and explicit, which helps users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (e.g., \uC with \code{_Accept}) or in terms of data (e.g., Go with channels). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control-flow semantics were chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The previous example shows a simple use \code{_Accept} versus \code{wait}/\code{signal} and its advantages. Note that while other languages often use \code{accept}/\code{select} as the core external scheduling keyword, \CFA uses \code{waitfor} to prevent name collisions with existing socket \acrshort{api}s.
+For the \code{P} member above using internal scheduling, the call to \code{wait} only guarantees that \code{V} is the last routine to access the monitor, allowing a third routine, say \code{isInUse()}, acquire mutual exclusion several times while routine \code{P} is waiting. On the other hand, external scheduling guarantees that while routine \code{P} is waiting, no routine other than \code{V} can acquire the monitor.
 % ======================================================================
 …
 % ======================================================================
 % ======================================================================
+In \uC, monitor declarations include an exhaustive list of monitor operations. Since \CFA is not object oriented it becomes both more difficult to implement but also less clear for the user:
+\begin{cfacode}
+        monitor A {};
+        void f(A & mutex a);
+        void f(int a, float b);
+        void g(A & mutex a) {
+                waitfor(f); // Less obvious which f() to wait for
+        }
+In \uC, monitor declarations include an exhaustive list of monitor operations. Since \CFA is not object oriented, monitors become both more difficult to implement and less clear for a user:
+\begin{cfacode}
+monitor A {};
+void f(A & mutex a);
+void g(A & mutex a) {
+        waitfor(f); //Obvious which f() to wait for
+}
+void f(A & mutex a, int); //New different F added in scope
+void h(A & mutex a) {
+        waitfor(f); //Less obvious which f() to wait for
+}
 \end{cfacode}
 …
         if monitor is free
                 enter
         elif I already own the monitor
+        elif already own the monitor
                 continue
         elif monitor accepts me
 …
 \end{center}
 For the fist two conditions, it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure:
+For the first two conditions, it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure:
 \begin{center}
 …
 \end{center}
 There are other alternatives to these pictures but in the case of this picture implementing a fast accept check is relatively easy. Indeed simply updating a bitmask when the acceptor queue changes is enough to have a check that executes in a single instruction, even with a fairly large number (e.g. 128) of mutex members. This technique cannot be used in \CFA because it relies on the fact that the monitor type declares all the acceptable routines. For OO languages this does not compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this is not the case; routines can be added to a type anywhere after its declaration. Its important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
 The alternative would be to have a picture more like this one:
+There are other alternatives to these pictures, but in the case of this picture, implementing a fast accept check is relatively easy. Restricted to a fixed number of mutex members, N, the accept check reduces to updating a bitmask when the acceptor queue changes, a check that executes in a single instruction even with a fairly large number (e.g., 128) of mutex members. This technique cannot be used in \CFA because it relies on the fact that the monitor type enumerates (declares) all the acceptable routines. For OO languages this does not compromise much since monitors already have an exhaustive list of member routines. However, for \CFA this is not the case; routines can be added to a type anywhere after its declaration. It is important to note that the bitmask approach does not actually require an exhaustive list of routines, but it requires a dense unique ordering of routines with an upper-bound and that ordering must be consistent across translation units.
+The alternative is to alter the implementeation like this:
 \begin{center}
 …
 \end{center}
+Not storing the queues inside the monitor means that the storage can vary between routines, allowing for more flexibility and extensions. Storing an array of function-pointers would solve the issue of uniquely identifying acceptable routines. However, the single instruction bitmask compare has been replaced by dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling may now require additionnal searches on calls to waitfor to check if a routine is already queued in.
+At this point we must make a decision between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed. In the end, the most flexible approach has been chosen since it allows users to write programs that would otherwise be prohibitively hard to write. This is based on the assumption that writing fast but inflexible locks is closer to a solved problems than writing locks that are as flexible as external scheduling in \CFA.
+Another aspect to consider is what happens if multiple overloads of the same routine are used. For the time being it is assumed that multiple overloads of the same routine are considered as distinct routines. However, this could easily be extended in the future.
+Generating a mask dynamically means that the storage for the mask information can vary between calls to \code{waitfor}, allowing for more flexibility and extensions. Storing an array of accepted function-pointers replaces the single instruction bitmask compare with dereferencing a pointer followed by a linear search. Furthermore, supporting nested external scheduling (e.g., listing \ref{lst:nest-ext}) may now require additionnal searches on calls to \code{waitfor} statement to check if a routine is already queued in.
+\begin{figure}
+\begin{cfacode}
+monitor M {};
+void foo( M & mutex a ) {}
+void bar( M & mutex b ) {
+        //Nested in the waitfor(bar, c) call
+        waitfor(foo, b);
+}
+void baz( M & mutex c ) {
+        waitfor(bar, c);
+}
+\end{cfacode}
+\caption{Example of nested external scheduling}
+\label{lst:nest-ext}
+\end{figure}
+Note that in the second picture, tasks need to always keep track of which routine they are attempting to acquire the monitor and the routine mask needs to have both a function pointer and a set of monitors, as will be discussed in the next section. These details where omitted from the picture for the sake of simplifying the representation.
+At this point, a decision must be made between flexibility and performance. Many design decisions in \CFA achieve both flexibility and performance, for example polymorphic routines add significant flexibility but inlining them means the optimizer can easily remove any runtime cost. Here however, the cost of flexibility cannot be trivially removed. In the end, the most flexible approach has been chosen since it allows users to write programs that would otherwise be prohibitively hard to write. This decision is based on the assumption that writing fast but inflexible locks is closer to a solved problems than writing locks that are as flexible as external scheduling in \CFA.
 % ======================================================================
 …
 % ======================================================================
 External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established:
 \begin{cfacode}
         mutex struct A {};
         mutex struct B {};
         void g(A & mutex a, B & mutex b) {
                 waitfor(f); //ambiguous, which monitor
+        }
+External scheduling, like internal scheduling, becomes significantly more complex when introducing multi-monitor syntax. Even in the simplest possible case, some new semantics need to be established:
+\begin{cfacode}
+monitor M {};
+void f(M & mutex a);
+void g(M & mutex b, M & mutex c) {
+        waitfor(f); //two monitors M => unkown which to pass to f(M & mutex)
+}
 \end{cfacode}
 …
 \begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor( f, b );
+        }
+\end{cfacode}
+This is unambiguous. Both locks will be acquired and kept, when routine \code{f} is called the lock for monitor \code{b} will be temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{a}). This behavior can be extended to multi-monitor waitfor statment as follows.
+\begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor( f, a, b);
+        }
+\end{cfacode}
+Note that the set of monitors passed to the \code{waitfor} statement must be entirely contained in the set of monitor already acquired in the routine. \code{waitfor} used in any other context is Undefined Behaviour.
+An important behavior to note is that what happens when set of monitors only match partially :
+\begin{cfacode}
+        mutex struct A {};
+        mutex struct B {};
+        void g(A & mutex a, B & mutex b) {
+                waitfor(f, a, b);
+        }
+        A a1, a2;
+        B b;
+        void foo() {
+                g(a1, b);
+        }
+        void bar() {
+                f(a2, b);
+        }
+\end{cfacode}
+While the equivalent can happen when using internal scheduling, the fact that conditions are branded on first use means that users have to use two different condition variables. In both cases, partially matching monitor sets will not wake-up the waiting thread. It is also important to note that in the case of external scheduling, as for routine calls, the order of parameters is important; \code{waitfor(f,a,b)} and \code{waitfor(f,b,a)} are to distinct waiting condition.
+% ======================================================================
+% ======================================================================
+\subsection{Implementation Details: External scheduling queues}
+% ======================================================================
+% ======================================================================
+To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program.
+% ======================================================================
+% ======================================================================
+\section{Other concurrency tools}
+% ======================================================================
+% ======================================================================
+% \TODO
+monitor M {};
+void f(M & mutex a);
+void g(M & mutex a, M & mutex b) {
+        waitfor( f, b );
+}
+\end{cfacode}
+This syntax is unambiguous. Both locks are acquired and kept by \code{g}. When routine \code{f} is called, the lock for monitor \code{b} is temporarily transferred from \code{g} to \code{f} (while \code{g} still holds lock \code{a}). This behavior can be extended to multi-monitor \code{waitfor} statement as follows.
+\begin{cfacode}
+monitor M {};
+void f(M & mutex a, M & mutex b);
+void g(M & mutex a, M & mutex b) {
+        waitfor( f, a, b);
+}
+\end{cfacode}
+Note that the set of monitors passed to the \code{waitfor} statement must be entirely contained in the set of monitors already acquired in the routine. \code{waitfor} used in any other context is Undefined Behaviour.
+An important behavior to note is when a set of monitors only match partially :
+\begin{cfacode}
+mutex struct A {};
+mutex struct B {};
+void g(A & mutex a, B & mutex b) {
+        waitfor(f, a, b);
+}
+A a1, a2;
+B b;
+void foo() {
+        g(a1, b); //block on accept
+}
+void bar() {
+        f(a2, b); //fufill cooperation
+}
+\end{cfacode}
+While the equivalent can happen when using internal scheduling, the fact that conditions are specific to a set of monitors means that users have to use two different condition variables. In both cases, partially matching monitor sets does not wake-up the waiting thread. It is also important to note that in the case of external scheduling, as for routine calls, the order of parameters is irrelevant; \code{waitfor(f,a,b)} and \code{waitfor(f,b,a)} are indistinguishable waiting condition.
+% ======================================================================
+% ======================================================================
+\subsection{\code{waitfor} semantics}
+% ======================================================================
+% ======================================================================
+Syntactically, the \code{waitfor} statement takes a function identifier and a set of monitors. While the set of monitors can be any list of expression, the function name is more restricted because the compiler validates at compile time the validity of the function type and the parameters used with the \code{waitfor} statement. It checks that the set of monitor passed in matches the requirements for a function call. Listing \ref{lst:waitfor} shows various usage of the waitfor statement and which are acceptable. The choice of the function type is made ignoring any non-\code{mutex} parameter. One limitation of the current implementation is that it does not handle overloading.
+\begin{figure}
+\begin{cfacode}
+monitor A{};
+monitor B{};
+void f1( A & mutex );
+void f2( A & mutex, B & mutex );
+void f3( A & mutex, int );
+void f4( A & mutex, int );
+void f4( A & mutex, double );
+void foo( A & mutex a1, A & mutex a2, B & mutex b1, B & b2 ) {
+        A * ap = & a1;
+        void (*fp)( A & mutex ) = f1;
+        waitfor(f1, a1);     //Correct : 1 monitor case
+        waitfor(f2, a1, b1); //Correct : 2 monitor case
+        waitfor(f3, a1);     //Correct : non-mutex arguments are ignored
+        waitfor(f1, *ap);    //Correct : expression as argument
+        waitfor(f1, a1, b1); //Incorrect : Too many mutex arguments
+        waitfor(f2, a1);     //Incorrect : Too few mutex arguments
+        waitfor(f2, a1, a2); //Incorrect : Mutex arguments don't match
+        waitfor(f1, 1);      //Incorrect : 1 not a mutex argument
+        waitfor(f9, a1);     //Incorrect : f9 function does not exist
+        waitfor(*fp, a1 );   //Incorrect : fp not an identifier
+        waitfor(f4, a1);     //Incorrect : f4 ambiguous
+        waitfor(f2, a1, b2); //Undefined Behaviour : b2 may not acquired
+}
+\end{cfacode}
+\caption{Various correct and incorrect uses of the waitfor statement}
+\label{lst:waitfor}
+\end{figure}
+Finally, for added flexibility, \CFA supports constructing complex \code{waitfor} mask using the \code{or}, \code{timeout} and \code{else}. Indeed, multiple \code{waitfor} can be chained together using \code{or}; this chain forms a single statement that uses baton-pass to any one function that fits one of the function+monitor set passed in. To eanble users to tell which accepted function is accepted, \code{waitfor}s are followed by a statement (including the null statement \code{;}) or a compound statement. When multiple \code{waitfor} are chained together, only the statement corresponding to the accepted function is executed. A \code{waitfor} chain can also be followed by a \code{timeout}, to signify an upper bound on the wait, or an \code{else}, to signify that the call should be non-blocking, that is only check of a matching function call already arrived and return immediately otherwise. Any and all of these clauses can be preceded by a \code{when} condition to dynamically construct the mask based on some current state. Listing \ref{lst:waitfor2}, demonstrates several complex masks and some incorrect ones.
+\begin{figure}
+\begin{cfacode}
+monitor A{};
+void f1( A & mutex );
+void f2( A & mutex );
+void foo( A & mutex a, bool b, int t ) {
+        //Correct : blocking case
+        waitfor(f1, a);
+        //Correct : block with statement
+        waitfor(f1, a) {
+                sout | "f1" | endl;
+        }
+        //Correct : block waiting for f1 or f2
+        waitfor(f1, a) {
+                sout | "f1" | endl;
+        } or waitfor(f2, a) {
+                sout | "f2" | endl;
+        }
+        //Correct : non-blocking case
+        waitfor(f1, a); or else;
+        //Correct : non-blocking case
+        waitfor(f1, a) {
+                sout | "blocked" | endl;
+        } or else {
+                sout | "didn't block" | endl;
+        }
+        //Correct : block at most 10 seconds
+        waitfor(f1, a) {
+                sout | "blocked" | endl;
+        } or timeout( 10`s) {
+                sout | "didn't block" | endl;
+        }
+        //Correct : block only if b == true
+        //if b == false, don't even make the call
+        when(b) waitfor(f1, a);
+        //Correct : block only if b == true
+        //if b == false, make non-blocking call
+        waitfor(f1, a); or when(!b) else;
+        //Correct : block only of t > 1
+        waitfor(f1, a); or when(t > 1) timeout(t); or else;
+        //Incorrect : timeout clause is dead code
+        waitfor(f1, a); or timeout(t); or else;
+        //Incorrect : order must be
+        //waitfor [or waitfor... [or timeout] [or else]]
+        timeout(t); or waitfor(f1, a); or else;
+}
+\end{cfacode}
+\caption{Various correct and incorrect uses of the or, else, and timeout clause around a waitfor statement}
+\label{lst:waitfor2}
+\end{figure}
+% ======================================================================
+% ======================================================================
+\subsection{Waiting for the destructor}
+% ======================================================================
+% ======================================================================
+An interesting use for the \code{waitfor} statement is destructor semantics. Indeed, the \code{waitfor} statement can accept any \code{mutex} routine, which includes the destructor (see section \ref{data}). However, with the semantics discussed until now, waiting for the destructor does not make any sense since using an object after its destructor is called is undefined behaviour. The simplest approach is to disallow \code{waitfor} on a destructor. However, a more expressive approach is to flip execution ordering when waiting for the destructor, meaning that waiting for the destructor allows the destructor to run after the current \code{mutex} routine, similarly to how a condition is signalled.
+\begin{figure}
+\begin{cfacode}
+monitor Executer {};
+struct  Action;
+void ^?{}   (Executer & mutex this);
+void execute(Executer & mutex this, const Action & );
+void run    (Executer & mutex this) {
+        while(true) {
+                   waitfor(execute, this);
+                or waitfor(^?{}   , this) {
+                        break;
+                }
+        }
+}
+\end{cfacode}
+\caption{Example of an executor which executes action in series until the destructor is called.}
+\label{lst:dtor-order}
+\end{figure}
+For example, listing \ref{lst:dtor-order} shows an example of an executor with an infinite loop, which waits for the destructor to break out of this loop. Switching the semantic meaning introduces an idiomatic way to terminate a task and/or wait for its termination via destruction.

doc/proposals/concurrency/text/intro.tex

-              r78315272
+              r3f7e12cb
 % ======================================================================
 This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency, in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adapted in \CFA
+This thesis provides a minimal concurrency \acrshort{api} that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of concurrency. Indeed, for highly productive concurrent programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. The high-level approach and its minimal \acrshort{api} are tested in a dialect of C, call \CFA. Furthermore, the proposed \acrshort{api} doubles as an early definition of the \CFA language and library. This thesis also comes with an implementation of the concurrency library for \CFA as well as all the required language features added to the source-to-source translator.
 There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the users. While these two concepts are often combined, they are in fact distinct concepts that require different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.
+There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the programmer. While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization.

doc/proposals/concurrency/text/parallelism.tex

-              r78315272
+              r3f7e12cb
 \section{Paradigm}
 \subsection{User-level threads}
 A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
+A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensive costs of kernel threads. The down side is that almost none of the low-level threading problems are hidden; users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
 Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
 \subsection{Fibers : user-level threads without preemption}
 A popular varient of \glspl{uthread} is what is often reffered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
+A popular varient of \glspl{uthread} is what is often refered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. The significant difference between \glspl{uthread} and \glspl{fiber} is the lack of \gls{preemption} in the later one. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial, and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignores fibers.
 An example of a language that uses fibers is Go~\cite{Go}
 \subsection{Jobs and thread pools}
 The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
+An approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work, called jobs, and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limit the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores.
 The gold standard of this implementation is Intel's TBB library~\cite{TBB}.
 \subsection{Paradigm performance}
 While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches will be more expansive and the extra control means users need to tweak more variables to get the desired performance. Furthermore, if the units of uninterrupted work are large enough the paradigm choice is largely amorticised by the actual work done.
+While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead (i.e., no thread stack per job). However, interactions among jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but a context switch is more expensive and the extra control means users need to tweak more variables to get the desired performance. Finally, if the units of uninterrupted work are large enough the paradigm choice is largely amortised by the actual work done.
+\newpage
+\TODO
+\subsection{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel}
+\section{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel}
+\Glspl{cfacluster} have not been fully implmented in the context of this thesis, currently \CFA only supports one \gls{cfacluster}, the initial one. The objective of \gls{cfacluster} is to group \gls{kthread} with identical settings together. \Glspl{uthread} can be scheduled on a \glspl{kthread} of a given \gls{cfacluster}, allowing organization between \glspl{kthread} and \glspl{uthread}. It is important that \glspl{kthread} belonging to a same \glspl{cfacluster} have homogenous settings, otherwise migrating a \gls{uthread} from one \gls{kthread} to the other can cause issues.
+\subsection{Future Work: Machine setup}\label{machine}
+While this was not done in the context of this thesis, another important aspect of clusters is affinity. While many common desktop and laptop PCs have homogeneous CPUs, other devices often have more heteregenous setups. For example, system using \acrshort{numa} configurations may benefit from users being able to tie clusters and/or kernel threads to certains CPU cores. OS support for CPU affinity is now common \cit, which means it is both possible and desirable for \CFA to offer an abstraction mechanism for portable CPU affinity.
 \subsection{Paradigms}\label{cfaparadigms}
+Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application.
+% \subsection{High-level options}\label{tasks}
+%
+% \subsubsection{Thread interface}
+% constructors destructors
+%       initializer lists
+% monitors
+%
+% \subsubsection{Futures}
+%
+% \subsubsection{Implicit threading}
+% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level.
+%
+% \begin{center}
+% \begin{tabular}[t]{|c|c|c|}
+% Sequential & System Parallel & Language Parallel \\
+% \begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       for(int i = 0; i < length; ++i ) {
+%               out[i] = a[i] + b[i];
+%       }
+% }
+%
+%
+%
+%
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting} &\begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       range ar(a, a + length);
+%       range br(b, b + length);
+%       range or(out, out + length);
+%       parfor( ai, bi, oi,
+%       [](int* ai, int* bi, int* oi) {
+%               oi = ai + bi;
+%       });
+% }
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting}&\begin{lstlisting}
+% void big_sum(int* a, int* b,
+%                int* out,
+%                size_t length)
+% {
+%       for (ai, bi, oi) in (a, b, out) {
+%               oi = ai + bi;
+%       }
+% }
+%
+%
+%
+%
+%
+% int* a[10000];
+% int* b[10000];
+% int* c[10000];
+% //... fill in a and b ...
+% big_sum(a, b, c, 10000);
+% \end{lstlisting}
+% \end{tabular}
+% \end{center}
+%
+% \subsection{Machine setup}\label{machine}
+% Threads are all good and well but wee still some OS support to fully utilize available hardware.
+%
+% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads?
+Given these building blocks, it is possible to reproduce all three of the popular paradigms. Indeed, \glspl{uthread} is the default paradigm in \CFA. However, disabling \gls{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. Finally, it is possible to build executors for thread pools from \glspl{uthread} or \glspl{fiber}.

doc/proposals/concurrency/thesis.tex

-              r78315272
+              r3f7e12cb
 % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended
 % inline code ©...© (copyright symbol) emacs: C-q M-)
 % red highlighting ®...® (registered trademark symbol) emacs: C-q M-.
 % blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_
 % green highlighting ¢...¢ (cent symbol) emacs: C-q M-"
 % LaTex escape §...§ (section symbol) emacs: C-q M-'
 % keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^
+% inline code �...� (copyright symbol) emacs: C-q M-)
+% red highlighting �...� (registered trademark symbol) emacs: C-q M-.
+% blue highlighting �...� (sharp s symbol) emacs: C-q M-_
+% green highlighting �...� (cent symbol) emacs: C-q M-"
+% LaTex escape �...� (section symbol) emacs: C-q M-'
+% keyword escape �...� (pilcrow symbol) emacs: C-q M-^
 % math escape $...$ (dollar symbol)
 …
 \usepackage{multicol}
 \usepackage[acronym]{glossaries}
 \usepackage{varioref}
+\usepackage{varioref}
 \usepackage{listings}                                           % format program code
 \usepackage[flushmargin]{footmisc}                              % support label/reference in footnote
 …
 \usepackage[pagewise]{lineno}
 \usepackage{fancyhdr}
+\usepackage{float}
 \renewcommand{\linenumberfont}{\scriptsize\sffamily}
+\usepackage{siunitx}
+\sisetup{ binary-units=true }
 \input{style}                                                   % bespoke macros used in the document
 \usepackage[dvips,plainpages=false,pdfpagelabels,pdfpagemode=UseNone,colorlinks=true,pagebackref=true,linkcolor=blue,citecolor=blue,urlcolor=blue,pagebackref=true,breaklinks=true]{hyperref}
 …
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \setcounter{secnumdepth}{3}                           % number subsubsections
 \setcounter{tocdepth}{3}                              % subsubsections in table of contents
+\setcounter{secnumdepth}{2}                           % number subsubsections
+\setcounter{tocdepth}{2}                              % subsubsections in table of contents
 % \linenumbers                                          % comment out to turn off line numbering
 \makeindex
 …
 \input{parallelism}
+\chapter{Putting it all together}
+\input{internals}
+\input{together}
+\input{results}
+\input{future}
 \chapter{Conclusion}
-\chapter{Future work}
-Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA.
-\subsection{Transactions}
 \section*{Acknowledgements}

doc/proposals/concurrency/version

r78315272	r3f7e12cb
1		0.~~9.180~~
	1	0.11.47

src/CodeGen/CodeGenerator.cc

-              r78315272
+              r3f7e12cb
         void CodeGenerator::postvisit( TypeDecl * typeDecl ) {
                 assertf( ! genC, "TypeDecls should not reach code generation." );
                 output << typeDecl->genTypeString() << " " << typeDecl->get_name();
                 if ( typeDecl->get_kind() != TypeDecl::Any && typeDecl->get_sized() ) {
                         output << " | sized(" << typeDecl->get_name() << ")";
+                }
                 if ( ! typeDecl->get_assertions().empty() ) {
+                output << typeDecl->genTypeString() << " " << typeDecl->name;
+                if ( typeDecl->sized ) {
+                        output << " | sized(" << typeDecl->name << ")";
+                }
+                if ( ! typeDecl->assertions.empty() ) {
                         output << " | { ";
+                        genCommaList( typeDecl->get_assertions().begin(), typeDecl->get_assertions().end() );
+                        for ( DeclarationWithType * assert :  typeDecl->assertions ) {
+                                assert->accept( *visitor );
+                                output << "; ";
+                        }
                         output << " }";
+                }
 …
         void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
                 extension( untypedExpr );
                 if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
+                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
                         OperatorInfo opInfo;
                         if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = untypedExpr->get_args().begin();
+                        if ( operatorLookup( nameExpr->name, opInfo ) ) {
+                                std::list< Expression* >::iterator arg = untypedExpr->args.begin();
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
                                         assert( untypedExpr->get_args().size() == 2 );
+                                        assert( untypedExpr->args.size() == 2 );
                                         (*arg++)->accept( *visitor );
                                         output << "[";
 …
                                   case OT_CTOR:
                                   case OT_DTOR:
                                         if ( untypedExpr->get_args().size() == 1 ) {
+                                        if ( untypedExpr->args.size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor may contain side
                                                 // effects, so must still output this expression
 …
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol << "{ ";
                                                 genCommaList( arg, untypedExpr->get_args().end() );
+                                                genCommaList( arg, untypedExpr->args.end() );
                                                 output << "}) /* " << opInfo.inputName << " */";
                                         } // if
 …
                                   case OT_PREFIXASSIGN:
                                   case OT_LABELADDRESS:
                                         assert( untypedExpr->get_args().size() == 1 );
+                                        assert( untypedExpr->args.size() == 1 );
                                         output << "(";
                                         output << opInfo.symbol;
 …
                                   case OT_POSTFIX:
                                   case OT_POSTFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 1 );
+                                        assert( untypedExpr->args.size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo.symbol;
 …
                                   case OT_INFIX:
                                   case OT_INFIXASSIGN:
                                         assert( untypedExpr->get_args().size() == 2 );
+                                        assert( untypedExpr->args.size() == 2 );
                                         output << "(";
                                         (*arg++)->accept( *visitor );
 …
                                 } // switch
                         } else {
+                                if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
+                                        assert( untypedExpr->get_args().size() == 2 );
+                                        (*untypedExpr->get_args().begin())->accept( *visitor );
+                                        output << " ... ";
+                                        (*--untypedExpr->get_args().end())->accept( *visitor );
+                                } else {                                                                // builtin routines
+                                        nameExpr->accept( *visitor );
+                                        output << "(";
+                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                                        output << ")";
+                                } // if
+                                // builtin routines
+                                nameExpr->accept( *visitor );
+                                output << "(";
+                                genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
+                                output << ")";
                         } // if
                 } else {
                         untypedExpr->get_function()->accept( *visitor );
+                        untypedExpr->function->accept( *visitor );
                         output << "(";
                         genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                        genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
                         output << ")";
                 } // if
 …
         void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
                 rangeExpr->get_low()->accept( *visitor );
+                rangeExpr->low->accept( *visitor );
                 output << " ... ";
                 rangeExpr->get_high()->accept( *visitor );
+                rangeExpr->high->accept( *visitor );
+        }
 …
                 extension( nameExpr );
                 OperatorInfo opInfo;
+                if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
+                        assert( opInfo.type == OT_CONSTANT );
+                        output << opInfo.symbol;
+                if ( operatorLookup( nameExpr->name, opInfo ) ) {
+                        if ( opInfo.type == OT_CONSTANT ) {
+                                output << opInfo.symbol;
+                        } else {
+                                output << opInfo.outputName;
+                        }
                 } else {
                         output << nameExpr->get_name();
 …
         void CodeGenerator::postvisit( CaseStmt * caseStmt ) {
+                updateLocation( caseStmt );
+                output << indent;
                 if ( caseStmt->isDefault()) {
                         output << "default";
 …
                 output << ";";
+        }
+        void CodeGenerator::postvisit( CatchStmt * stmt ) {
+                assertf( ! genC, "Catch statements should not reach code generation." );
+                output << ((stmt->get_kind() == CatchStmt::Terminate) ?
+                "catch" : "catchResume");
+                output << "( ";
+                stmt->decl->accept( *visitor );
+                output << " ) ";
+                if( stmt->cond ) {
+                        output << "if/when(?) (";
+                        stmt->cond->accept( *visitor );
+                        output << ") ";
+                }
+                stmt->body->accept( *visitor );
+        }
+        void CodeGenerator::postvisit( WaitForStmt * stmt ) {
+                assertf( ! genC, "Waitfor statements should not reach code generation." );
+                bool first = true;
+                for( auto & clause : stmt->clauses ) {
+                        if(first) { output << "or "; first = false; }
+                        if( clause.condition ) {
+                                output << "when(";
+                                stmt->timeout.condition->accept( *visitor );
+                                output << ") ";
+                        }
+                        output << "waitfor(";
+                        clause.target.function->accept( *visitor );
+                        for( Expression * expr : clause.target.arguments ) {
+                                output << ",";
+                                expr->accept( *visitor );
+                        }
+                        output << ") ";
+                        clause.statement->accept( *visitor );
+                }
+                if( stmt->timeout.statement ) {
+                        output << "or ";
+                        if( stmt->timeout.condition ) {
+                                output << "when(";
+                                stmt->timeout.condition->accept( *visitor );
+                                output << ") ";
+                        }
+                        output << "timeout(";
+                        stmt->timeout.time->accept( *visitor );
+                        output << ") ";
+                        stmt->timeout.statement->accept( *visitor );
+                }
+                if( stmt->orelse.statement ) {
+                        output << "or ";
+                        if( stmt->orelse.condition ) {
+                                output << "when(";
+                                stmt->orelse.condition->accept( *visitor );
+                                output << ")";
+                        }
+                        output << "else ";
+                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
 …
+        }
 } // namespace CodeGen
+unsigned Indenter::tabsize = 2;
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) {
+        if ( node ) {
+                node->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+}
 // Local Variables: //

src/CodeGen/CodeGenerator.h

r78315272	r3f7e12cb
100	100	void postvisit( ReturnStmt * );
101	101	void postvisit( ThrowStmt * );
	102	void postvisit( CatchStmt * );
	103	void postvisit( WaitForStmt * );
102	104	void postvisit( WhileStmt * );
103	105	void postvisit( ForStmt * );

src/CodeGen/FixNames.cc

-              r78315272
+              r3f7e12cb
                 );
                 mainDecl->get_functionType()->get_parameters().push_back(
+                main_type->get_parameters().push_back(
                         new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
                 );
                 mainDecl->get_functionType()->get_parameters().push_back(
+                main_type->get_parameters().push_back(
                         new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
                         new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),

src/CodeGen/GenType.cc

-              r78315272
+              r3f7e12cb
         std::string GenType::handleGeneric( ReferenceToType * refType ) {
                 if ( ! refType->get_parameters().empty() ) {
+                if ( ! refType->parameters.empty() ) {
                         std::ostringstream os;
                         PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         os << "(";
                         cg.pass.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
+                        cg.pass.genCommaList( refType->parameters.begin(), refType->parameters.end() );
                         os << ") ";
                         return os.str();

src/Common/Indenter.h

-              r78315272
+              r3f7e12cb
 struct Indenter {
+        Indenter( unsigned int amt = 2 ) : amt( amt ) {}
+        unsigned int amt = 2;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
+        unsigned int indent = 0;
+        static unsigned tabsize;
+        Indenter( unsigned int amt = tabsize, unsigned int indent = 0 ) : amt( amt ), indent( indent ) {}
+        unsigned int amt;  // amount 1 level increases indent by (i.e. how much to increase by in operator++)
+        unsigned int indent;
         Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
 …
 };
 inline std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
+inline std::ostream & operator<<( std::ostream & out, const Indenter & indent ) {
         return out << std::string(indent.indent, ' ');
+}

src/Common/PassVisitor.h

-              r78315272
+              r3f7e12cb
 #include <stack>
+#include "Common/utility.h"
 #include "SynTree/Mutator.h"
 …
 #include "SymTab/Indexer.h"
+#include "SynTree/Attribute.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
 …
         pass_type pass;
+        virtual void visit( ObjectDecl *objectDecl ) override final;
+        virtual void visit( FunctionDecl *functionDecl ) override final;
+        virtual void visit( StructDecl *aggregateDecl ) override final;
+        virtual void visit( UnionDecl *aggregateDecl ) override final;
+        virtual void visit( EnumDecl *aggregateDecl ) override final;
+        virtual void visit( TraitDecl *aggregateDecl ) override final;
+        virtual void visit( TypeDecl *typeDecl ) override final;
+        virtual void visit( TypedefDecl *typeDecl ) override final;
+        virtual void visit( AsmDecl *asmDecl ) override final;
+        virtual void visit( CompoundStmt *compoundStmt ) override final;
+        virtual void visit( ExprStmt *exprStmt ) override final;
+        virtual void visit( AsmStmt *asmStmt ) override final;
+        virtual void visit( IfStmt *ifStmt ) override final;
+        virtual void visit( WhileStmt *whileStmt ) override final;
+        virtual void visit( ForStmt *forStmt ) override final;
+        virtual void visit( SwitchStmt *switchStmt ) override final;
+        virtual void visit( CaseStmt *caseStmt ) override final;
+        virtual void visit( BranchStmt *branchStmt ) override final;
+        virtual void visit( ReturnStmt *returnStmt ) override final;
+        virtual void visit( ThrowStmt *throwStmt ) override final;
+        virtual void visit( TryStmt *tryStmt ) override final;
+        virtual void visit( CatchStmt *catchStmt ) override final;
+        virtual void visit( FinallyStmt *finallyStmt ) override final;
+        virtual void visit( WaitForStmt *waitforStmt ) override final;
+        virtual void visit( NullStmt *nullStmt ) override final;
+        virtual void visit( DeclStmt *declStmt ) override final;
+        virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final;
+        virtual void visit( ApplicationExpr *applicationExpr ) override final;
+        virtual void visit( UntypedExpr *untypedExpr ) override final;
+        virtual void visit( NameExpr *nameExpr ) override final;
+        virtual void visit( CastExpr *castExpr ) override final;
+        virtual void visit( VirtualCastExpr *castExpr ) override final;
+        virtual void visit( AddressExpr *addressExpr ) override final;
+        virtual void visit( LabelAddressExpr *labAddressExpr ) override final;
+        virtual void visit( UntypedMemberExpr *memberExpr ) override final;
+        virtual void visit( MemberExpr *memberExpr ) override final;
+        virtual void visit( VariableExpr *variableExpr ) override final;
+        virtual void visit( ConstantExpr *constantExpr ) override final;
+        virtual void visit( SizeofExpr *sizeofExpr ) override final;
+        virtual void visit( AlignofExpr *alignofExpr ) override final;
+        virtual void visit( UntypedOffsetofExpr *offsetofExpr ) override final;
+        virtual void visit( OffsetofExpr *offsetofExpr ) override final;
+        virtual void visit( OffsetPackExpr *offsetPackExpr ) override final;
+        virtual void visit( AttrExpr *attrExpr ) override final;
+        virtual void visit( LogicalExpr *logicalExpr ) override final;
+        virtual void visit( ConditionalExpr *conditionalExpr ) override final;
+        virtual void visit( CommaExpr *commaExpr ) override final;
+        virtual void visit( TypeExpr *typeExpr ) override final;
+        virtual void visit( AsmExpr *asmExpr ) override final;
+        virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr ) override final;
+        virtual void visit( ConstructorExpr * ctorExpr ) override final;
+        virtual void visit( CompoundLiteralExpr *compLitExpr ) override final;
+        virtual void visit( RangeExpr *rangeExpr ) override final;
+        virtual void visit( UntypedTupleExpr *tupleExpr ) override final;
+        virtual void visit( TupleExpr *tupleExpr ) override final;
+        virtual void visit( TupleIndexExpr *tupleExpr ) override final;
+        virtual void visit( TupleAssignExpr *assignExpr ) override final;
+        virtual void visit( StmtExpr * stmtExpr ) override final;
+        virtual void visit( UniqueExpr * uniqueExpr ) override final;
+        virtual void visit( VoidType *basicType ) override final;
+        virtual void visit( BasicType *basicType ) override final;
+        virtual void visit( PointerType *pointerType ) override final;
+        virtual void visit( ArrayType *arrayType ) override final;
+        virtual void visit( ReferenceType *referenceType ) override final;
+        virtual void visit( FunctionType *functionType ) override final;
+        virtual void visit( StructInstType *aggregateUseType ) override final;
+        virtual void visit( UnionInstType *aggregateUseType ) override final;
+        virtual void visit( EnumInstType *aggregateUseType ) override final;
+        virtual void visit( TraitInstType *aggregateUseType ) override final;
+        virtual void visit( TypeInstType *aggregateUseType ) override final;
+        virtual void visit( TupleType *tupleType ) override final;
+        virtual void visit( TypeofType *typeofType ) override final;
+        virtual void visit( AttrType *attrType ) override final;
+        virtual void visit( VarArgsType *varArgsType ) override final;
+        virtual void visit( ZeroType *zeroType ) override final;
+        virtual void visit( OneType *oneType ) override final;
+        virtual void visit( Designation *designation ) override final;
+        virtual void visit( SingleInit *singleInit ) override final;
+        virtual void visit( ListInit *listInit ) override final;
+        virtual void visit( ConstructorInit *ctorInit ) override final;
+        virtual void visit( Subrange *subrange ) override final;
+        virtual void visit( Constant *constant ) override final;
+        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override final;
+        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override final;
+        virtual Declaration* mutate( StructDecl *aggregateDecl ) override final;
+        virtual Declaration* mutate( UnionDecl *aggregateDecl ) override final;
+        virtual Declaration* mutate( EnumDecl *aggregateDecl ) override final;
+        virtual Declaration* mutate( TraitDecl *aggregateDecl ) override final;
+        virtual Declaration* mutate( TypeDecl *typeDecl ) override final;
+        virtual Declaration* mutate( TypedefDecl *typeDecl ) override final;
+        virtual AsmDecl* mutate( AsmDecl *asmDecl ) override final;
+        virtual CompoundStmt* mutate( CompoundStmt *compoundStmt ) override final;
+        virtual Statement* mutate( ExprStmt *exprStmt ) override final;
+        virtual Statement* mutate( AsmStmt *asmStmt ) override final;
+        virtual Statement* mutate( IfStmt *ifStmt ) override final;
+        virtual Statement* mutate( WhileStmt *whileStmt ) override final;
+        virtual Statement* mutate( ForStmt *forStmt ) override final;
+        virtual Statement* mutate( SwitchStmt *switchStmt ) override final;
+        virtual Statement* mutate( CaseStmt *caseStmt ) override final;
+        virtual Statement* mutate( BranchStmt *branchStmt ) override final;
+        virtual Statement* mutate( ReturnStmt *returnStmt ) override final;
+        virtual Statement* mutate( ThrowStmt *throwStmt ) override final;
+        virtual Statement* mutate( TryStmt *tryStmt ) override final;
+        virtual Statement* mutate( CatchStmt *catchStmt ) override final;
+        virtual Statement* mutate( FinallyStmt *finallyStmt ) override final;
+        virtual Statement* mutate( WaitForStmt *waitforStmt ) override final;
+        virtual NullStmt* mutate( NullStmt *nullStmt ) override final;
+        virtual Statement* mutate( DeclStmt *declStmt ) override final;
+        virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt ) override final;
+        virtual Expression* mutate( ApplicationExpr *applicationExpr ) override final;
+        virtual Expression* mutate( UntypedExpr *untypedExpr ) override final;
+        virtual Expression* mutate( NameExpr *nameExpr ) override final;
+        virtual Expression* mutate( AddressExpr *castExpr ) override final;
+        virtual Expression* mutate( LabelAddressExpr *labAddressExpr ) override final;
+        virtual Expression* mutate( CastExpr *castExpr ) override final;
+        virtual Expression* mutate( VirtualCastExpr *castExpr ) override final;
+        virtual Expression* mutate( UntypedMemberExpr *memberExpr ) override final;
+        virtual Expression* mutate( MemberExpr *memberExpr ) override final;
+        virtual Expression* mutate( VariableExpr *variableExpr ) override final;
+        virtual Expression* mutate( ConstantExpr *constantExpr ) override final;
+        virtual Expression* mutate( SizeofExpr *sizeofExpr ) override final;
+        virtual Expression* mutate( AlignofExpr *alignofExpr ) override final;
+        virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr ) override final;
+        virtual Expression* mutate( OffsetofExpr *offsetofExpr ) override final;
+        virtual Expression* mutate( OffsetPackExpr *offsetPackExpr ) override final;
+        virtual Expression* mutate( AttrExpr *attrExpr ) override final;
+        virtual Expression* mutate( LogicalExpr *logicalExpr ) override final;
+        virtual Expression* mutate( ConditionalExpr *conditionalExpr ) override final;
+        virtual Expression* mutate( CommaExpr *commaExpr ) override final;
+        virtual Expression* mutate( TypeExpr *typeExpr ) override final;
+        virtual Expression* mutate( AsmExpr *asmExpr ) override final;
+        virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr ) override final;
+        virtual Expression* mutate( ConstructorExpr *ctorExpr ) override final;
+        virtual Expression* mutate( CompoundLiteralExpr *compLitExpr ) override final;
+        virtual Expression* mutate( RangeExpr *rangeExpr ) override final;
+        virtual Expression* mutate( UntypedTupleExpr *tupleExpr ) override final;
+        virtual Expression* mutate( TupleExpr *tupleExpr ) override final;
+        virtual Expression* mutate( TupleIndexExpr *tupleExpr ) override final;
+        virtual Expression* mutate( TupleAssignExpr *assignExpr ) override final;
+        virtual Expression* mutate( StmtExpr * stmtExpr ) override final;
+        virtual Expression* mutate( UniqueExpr * uniqueExpr ) override final;
+        virtual Type* mutate( VoidType *basicType ) override final;
+        virtual Type* mutate( BasicType *basicType ) override final;
+        virtual Type* mutate( PointerType *pointerType ) override final;
+        virtual Type* mutate( ArrayType *arrayType ) override final;
+        virtual Type* mutate( ReferenceType *referenceType ) override final;
+        virtual Type* mutate( FunctionType *functionType ) override final;
+        virtual Type* mutate( StructInstType *aggregateUseType ) override final;
+        virtual Type* mutate( UnionInstType *aggregateUseType ) override final;
+        virtual Type* mutate( EnumInstType *aggregateUseType ) override final;
+        virtual Type* mutate( TraitInstType *aggregateUseType ) override final;
+        virtual Type* mutate( TypeInstType *aggregateUseType ) override final;
+        virtual Type* mutate( TupleType *tupleType ) override final;
+        virtual Type* mutate( TypeofType *typeofType ) override final;
+        virtual Type* mutate( AttrType *attrType ) override final;
+        virtual Type* mutate( VarArgsType *varArgsType ) override final;
+        virtual Type* mutate( ZeroType *zeroType ) override final;
+        virtual Type* mutate( OneType *oneType ) override final;
+        virtual Designation* mutate( Designation *designation ) override final;
+        virtual Initializer* mutate( SingleInit *singleInit ) override final;
+        virtual Initializer* mutate( ListInit *listInit ) override final;
+        virtual Initializer* mutate( ConstructorInit *ctorInit ) override final;
+        virtual Subrange *mutate( Subrange *subrange ) override final;
+        virtual Constant *mutate( Constant *constant ) override final;
+        virtual void visit( ObjectDecl * objectDecl ) override final;
+        virtual void visit( FunctionDecl * functionDecl ) override final;
+        virtual void visit( StructDecl * aggregateDecl ) override final;
+        virtual void visit( UnionDecl * aggregateDecl ) override final;
+        virtual void visit( EnumDecl * aggregateDecl ) override final;
+        virtual void visit( TraitDecl * aggregateDecl ) override final;
+        virtual void visit( TypeDecl * typeDecl ) override final;
+        virtual void visit( TypedefDecl * typeDecl ) override final;
+        virtual void visit( AsmDecl * asmDecl ) override final;
+        virtual void visit( CompoundStmt * compoundStmt ) override final;
+        virtual void visit( ExprStmt * exprStmt ) override final;
+        virtual void visit( AsmStmt * asmStmt ) override final;
+        virtual void visit( IfStmt * ifStmt ) override final;
+        virtual void visit( WhileStmt * whileStmt ) override final;
+        virtual void visit( ForStmt * forStmt ) override final;
+        virtual void visit( SwitchStmt * switchStmt ) override final;
+        virtual void visit( CaseStmt * caseStmt ) override final;
+        virtual void visit( BranchStmt * branchStmt ) override final;
+        virtual void visit( ReturnStmt * returnStmt ) override final;
+        virtual void visit( ThrowStmt * throwStmt ) override final;
+        virtual void visit( TryStmt * tryStmt ) override final;
+        virtual void visit( CatchStmt * catchStmt ) override final;
+        virtual void visit( FinallyStmt * finallyStmt ) override final;
+        virtual void visit( WaitForStmt * waitforStmt ) override final;
+        virtual void visit( NullStmt * nullStmt ) override final;
+        virtual void visit( DeclStmt * declStmt ) override final;
+        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
+        virtual void visit( ApplicationExpr * applicationExpr ) override final;
+        virtual void visit( UntypedExpr * untypedExpr ) override final;
+        virtual void visit( NameExpr * nameExpr ) override final;
+        virtual void visit( CastExpr * castExpr ) override final;
+        virtual void visit( VirtualCastExpr * castExpr ) override final;
+        virtual void visit( AddressExpr * addressExpr ) override final;
+        virtual void visit( LabelAddressExpr * labAddressExpr ) override final;
+        virtual void visit( UntypedMemberExpr * memberExpr ) override final;
+        virtual void visit( MemberExpr * memberExpr ) override final;
+        virtual void visit( VariableExpr * variableExpr ) override final;
+        virtual void visit( ConstantExpr * constantExpr ) override final;
+        virtual void visit( SizeofExpr * sizeofExpr ) override final;
+        virtual void visit( AlignofExpr * alignofExpr ) override final;
+        virtual void visit( UntypedOffsetofExpr * offsetofExpr ) override final;
+        virtual void visit( OffsetofExpr * offsetofExpr ) override final;
+        virtual void visit( OffsetPackExpr * offsetPackExpr ) override final;
+        virtual void visit( AttrExpr * attrExpr ) override final;
+        virtual void visit( LogicalExpr * logicalExpr ) override final;
+        virtual void visit( ConditionalExpr * conditionalExpr ) override final;
+        virtual void visit( CommaExpr * commaExpr ) override final;
+        virtual void visit( TypeExpr * typeExpr ) override final;
+        virtual void visit( AsmExpr * asmExpr ) override final;
+        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override final;
+        virtual void visit( ConstructorExpr *  ctorExpr ) override final;
+        virtual void visit( CompoundLiteralExpr * compLitExpr ) override final;
+        virtual void visit( RangeExpr * rangeExpr ) override final;
+        virtual void visit( UntypedTupleExpr * tupleExpr ) override final;
+        virtual void visit( TupleExpr * tupleExpr ) override final;
+        virtual void visit( TupleIndexExpr * tupleExpr ) override final;
+        virtual void visit( TupleAssignExpr * assignExpr ) override final;
+        virtual void visit( StmtExpr *  stmtExpr ) override final;
+        virtual void visit( UniqueExpr *  uniqueExpr ) override final;
+        virtual void visit( VoidType * basicType ) override final;
+        virtual void visit( BasicType * basicType ) override final;
+        virtual void visit( PointerType * pointerType ) override final;
+        virtual void visit( ArrayType * arrayType ) override final;
+        virtual void visit( ReferenceType * referenceType ) override final;
+        virtual void visit( FunctionType * functionType ) override final;
+        virtual void visit( StructInstType * aggregateUseType ) override final;
+        virtual void visit( UnionInstType * aggregateUseType ) override final;
+        virtual void visit( EnumInstType * aggregateUseType ) override final;
+        virtual void visit( TraitInstType * aggregateUseType ) override final;
+        virtual void visit( TypeInstType * aggregateUseType ) override final;
+        virtual void visit( TupleType * tupleType ) override final;
+        virtual void visit( TypeofType * typeofType ) override final;
+        virtual void visit( AttrType * attrType ) override final;
+        virtual void visit( VarArgsType * varArgsType ) override final;
+        virtual void visit( ZeroType * zeroType ) override final;
+        virtual void visit( OneType * oneType ) override final;
+        virtual void visit( Designation * designation ) override final;
+        virtual void visit( SingleInit * singleInit ) override final;
+        virtual void visit( ListInit * listInit ) override final;
+        virtual void visit( ConstructorInit * ctorInit ) override final;
+        virtual void visit( Subrange * subrange ) override final;
+        virtual void visit( Constant * constant ) override final;
+        virtual void visit( Attribute * attribute ) override final;
+        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override final;
+        virtual DeclarationWithType * mutate( FunctionDecl * functionDecl ) override final;
+        virtual Declaration * mutate( StructDecl * aggregateDecl ) override final;
+        virtual Declaration * mutate( UnionDecl * aggregateDecl ) override final;
+        virtual Declaration * mutate( EnumDecl * aggregateDecl ) override final;
+        virtual Declaration * mutate( TraitDecl * aggregateDecl ) override final;
+        virtual Declaration * mutate( TypeDecl * typeDecl ) override final;
+        virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
+        virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
+        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;
+        virtual Statement * mutate( ExprStmt * exprStmt ) override final;
+        virtual Statement * mutate( AsmStmt * asmStmt ) override final;
+        virtual Statement * mutate( IfStmt * ifStmt ) override final;
+        virtual Statement * mutate( WhileStmt * whileStmt ) override final;
+        virtual Statement * mutate( ForStmt * forStmt ) override final;
+        virtual Statement * mutate( SwitchStmt * switchStmt ) override final;
+        virtual Statement * mutate( CaseStmt * caseStmt ) override final;
+        virtual Statement * mutate( BranchStmt * branchStmt ) override final;
+        virtual Statement * mutate( ReturnStmt * returnStmt ) override final;
+        virtual Statement * mutate( ThrowStmt * throwStmt ) override final;
+        virtual Statement * mutate( TryStmt * tryStmt ) override final;
+        virtual Statement * mutate( CatchStmt * catchStmt ) override final;
+        virtual Statement * mutate( FinallyStmt * finallyStmt ) override final;
+        virtual Statement * mutate( WaitForStmt * waitforStmt ) override final;
+        virtual NullStmt * mutate( NullStmt * nullStmt ) override final;
+        virtual Statement * mutate( DeclStmt * declStmt ) override final;
+        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
+        virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final;
+        virtual Expression * mutate( UntypedExpr * untypedExpr ) override final;
+        virtual Expression * mutate( NameExpr * nameExpr ) override final;
+        virtual Expression * mutate( AddressExpr * castExpr ) override final;
+        virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) override final;
+        virtual Expression * mutate( CastExpr * castExpr ) override final;
+        virtual Expression * mutate( VirtualCastExpr * castExpr ) override final;
+        virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override final;
+        virtual Expression * mutate( MemberExpr * memberExpr ) override final;
+        virtual Expression * mutate( VariableExpr * variableExpr ) override final;
+        virtual Expression * mutate( ConstantExpr * constantExpr ) override final;
+        virtual Expression * mutate( SizeofExpr * sizeofExpr ) override final;
+        virtual Expression * mutate( AlignofExpr * alignofExpr ) override final;
+        virtual Expression * mutate( UntypedOffsetofExpr * offsetofExpr ) override final;
+        virtual Expression * mutate( OffsetofExpr * offsetofExpr ) override final;
+        virtual Expression * mutate( OffsetPackExpr * offsetPackExpr ) override final;
+        virtual Expression * mutate( AttrExpr * attrExpr ) override final;
+        virtual Expression * mutate( LogicalExpr * logicalExpr ) override final;
+        virtual Expression * mutate( ConditionalExpr * conditionalExpr ) override final;
+        virtual Expression * mutate( CommaExpr * commaExpr ) override final;
+        virtual Expression * mutate( TypeExpr * typeExpr ) override final;
+        virtual Expression * mutate( AsmExpr * asmExpr ) override final;
+        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override final;
+        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override final;
+        virtual Expression * mutate( CompoundLiteralExpr * compLitExpr ) override final;
+        virtual Expression * mutate( RangeExpr * rangeExpr ) override final;
+        virtual Expression * mutate( UntypedTupleExpr * tupleExpr ) override final;
+        virtual Expression * mutate( TupleExpr * tupleExpr ) override final;
+        virtual Expression * mutate( TupleIndexExpr * tupleExpr ) override final;
+        virtual Expression * mutate( TupleAssignExpr * assignExpr ) override final;
+        virtual Expression * mutate( StmtExpr *  stmtExpr ) override final;
+        virtual Expression * mutate( UniqueExpr *  uniqueExpr ) override final;
+        virtual Type * mutate( VoidType * basicType ) override final;
+        virtual Type * mutate( BasicType * basicType ) override final;
+        virtual Type * mutate( PointerType * pointerType ) override final;
+        virtual Type * mutate( ArrayType * arrayType ) override final;
+        virtual Type * mutate( ReferenceType * referenceType ) override final;
+        virtual Type * mutate( FunctionType * functionType ) override final;
+        virtual Type * mutate( StructInstType * aggregateUseType ) override final;
+        virtual Type * mutate( UnionInstType * aggregateUseType ) override final;
+        virtual Type * mutate( EnumInstType * aggregateUseType ) override final;
+        virtual Type * mutate( TraitInstType * aggregateUseType ) override final;
+        virtual Type * mutate( TypeInstType * aggregateUseType ) override final;
+        virtual Type * mutate( TupleType * tupleType ) override final;
+        virtual Type * mutate( TypeofType * typeofType ) override final;
+        virtual Type * mutate( AttrType * attrType ) override final;
+        virtual Type * mutate( VarArgsType * varArgsType ) override final;
+        virtual Type * mutate( ZeroType * zeroType ) override final;
+        virtual Type * mutate( OneType * oneType ) override final;
+        virtual Designation * mutate( Designation * designation ) override final;
+        virtual Initializer * mutate( SingleInit * singleInit ) override final;
+        virtual Initializer * mutate( ListInit * listInit ) override final;
+        virtual Initializer * mutate( ConstructorInit * ctorInit ) override final;
+        virtual Subrange * mutate( Subrange * subrange ) override final;
+        virtual Constant * mutate( Constant * constant ) override final;
+        virtual Attribute * mutate( Attribute * attribute ) override final;
+        virtual TypeSubstitution * mutate( TypeSubstitution * sub ) final;
 private:
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
         template<typename pass_t> friend void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
+        template< typename TreeType, typename pass_t > friend void maybeAccept_impl( TreeType * tree, PassVisitor< pass_t > & visitor );
+        template< typename TreeType, typename pass_t > friend void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_t > & mutator );
+        template< typename Container, typename pass_t > friend void maybeAccept_impl( Container & container, PassVisitor< pass_t > & visitor );
+        template< typename Container, typename pass_t > friend void maybeMutate_impl( Container & container, PassVisitor< pass_t > & mutator );
         template<typename node_type> void call_previsit ( node_type * node ) { previsit_impl ( pass, node, 0 ); }
 …
         std::list< Declaration* > *     get_afterDecls () { return declsToAddAfter_impl ( pass, 0); }
+        void set_visit_children( bool& ref ) { bool_ref * ptr = visit_children_impl(pass, 0); if(ptr) ptr->set( ref ); }
+        bool       get_visit_children    () { bool_ref * ptr = visit_children_impl(pass, 0); return ptr ? *ptr : true; }
+        bool_ref * get_visit_children_ptr() { return visit_children_impl(pass, 0); }
         void indexerScopeEnter  ()                             { indexer_impl_enterScope  ( pass, 0       ); }

src/Common/PassVisitor.impl.h

-              r78315272
+              r3f7e12cb
 // IWYU pragma: private, include "PassVisitor.h"
+#define VISIT_START( node )                     \
+        __attribute__((unused))                   \
+#define VISIT_START( node )                                     \
+        __attribute__((unused))                                   \
+        ChildrenGuard children_guard( get_visit_children_ptr() ); \
+        __attribute__((unused))                                   \
         guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
+        bool visit_children = true;               \
+        set_visit_children( visit_children );   \
+        call_previsit( node );                    \
+        if( visit_children ) {                    \
+        call_previsit( node );                                    \
 #define VISIT_END( node )                       \
-        }                                         \
         call_postvisit( node );                   \
+#define MUTATE_START( node )                    \
+        __attribute__((unused))                   \
+#define MUTATE_START( node )                                    \
+        __attribute__((unused))                                   \
+        ChildrenGuard children_guard( get_visit_children_ptr() ); \
+        __attribute__((unused))                                   \
         guard_value_impl guard( at_cleanup_impl(pass, 0) );       \
+        bool visit_children = true;               \
+        set_visit_children( visit_children );   \
+        call_premutate( node );                   \
+        if( visit_children ) {                    \
+        call_premutate( node );                                   \
 #define MUTATE_END( type, node )                \
-        }                                         \
         return call_postmutate< type * >( node ); \
+#define VISIT_BODY( node )        \
+        VISIT_START( node );        \
+        Visitor::visit( node );     \
+        VISIT_END( node );          \
+#define MUTATE_BODY( type, node ) \
+        MUTATE_START( node );       \
+        Mutator::mutate( node );    \
+        MUTATE_END( type, node );   \
+#define VISIT_BODY( node )          \
+        VISIT_START( node );          \
+        if( children_guard ) {        \
+                Visitor::visit( node ); \
+        }                             \
+        VISIT_END( node );            \
+#define MUTATE_BODY( type, node )    \
+        MUTATE_START( node );          \
+        if( children_guard ) {         \
+                Mutator::mutate( node ); \
+        }                              \
+        MUTATE_END( type, node );      \
 …
 template< typename pass_type >
 static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
         DeclList_t* beforeDecls = visitor.get_beforeDecls();
         DeclList_t* afterDecls  = visitor.get_afterDecls();
 …
                 try {
                         // run visitor on declaration
                         maybeAccept( *i, visitor );
+                        maybeAccept_impl( *i, visitor );
                 } catch( SemanticError &e ) {
                         e.set_location( (*i)->location );
 …
 template< typename pass_type >
 static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
         DeclList_t* beforeDecls = mutator.get_beforeDecls();
         DeclList_t* afterDecls  = mutator.get_afterDecls();
 …
                 try {
                         // run mutator on declaration
                         *i = maybeMutate( *i, mutator );
+                        maybeMutate_impl( *i, mutator );
                 } catch( SemanticError &e ) {
                         e.set_location( (*i)->location );
 …
+}
+template< typename Container, typename VisitorType >
+inline void maybeAccept( Container &container, VisitorType &visitor ) {
+template< typename TreeType, typename pass_type >
+inline void maybeAccept_impl( TreeType * tree, PassVisitor< pass_type > & visitor ) {
+        if ( ! visitor.get_visit_children() ) return;
+        if ( tree ) {
+                tree->accept( visitor );
+        }
+}
+template< typename Container, typename pass_type >
+inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
+        if ( ! visitor.get_visit_children() ) return;
         SemanticError errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
 …
+}
+template< typename Container, typename MutatorType >
+inline void maybeMutateRef( Container &container, MutatorType &mutator ) {
+template< typename TreeType, typename pass_type >
+inline void maybeMutate_impl( TreeType *& tree, PassVisitor< pass_type > & mutator ) {
+        if ( ! mutator.get_visit_children() ) return;
+        if ( tree ) {
+                tree = strict_dynamic_cast< TreeType * >( tree->acceptMutator( mutator ) );
+        }
+}
+template< typename Container, typename pass_type >
+inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
+        if ( ! mutator.get_visit_children() ) return;
         SemanticError errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
                         if ( *i ) {
-///                 *i = (*i)->acceptMutator( mutator );
                                 *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
                                 assert( *i );
 …
 template< typename func_t >
 void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
+        if ( ! get_visit_children() ) return;
         SemanticError errors;
 …
 void PassVisitor< pass_type >::visitStatementList( std::list< Statement * > & statements ) {
         handleStatementList( statements, [this]( Statement * stmt) {
                 stmt->accept( *this );
+                maybeAccept_impl( stmt, *this );
         });
+}
 …
 void PassVisitor< pass_type >::mutateStatementList( std::list< Statement * > & statements ) {
         handleStatementList( statements, [this]( Statement *& stmt) {
                 stmt = stmt->acceptMutator( *this );
+                maybeMutate_impl( stmt, *this );
         });
+}
 …
 template< typename func_t >
 Statement * PassVisitor< pass_type >::handleStatement( Statement * stmt, func_t func ) {
+        if ( ! get_visit_children() ) return stmt;
         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
         ValueGuardPtr< TypeSubstitution * >  oldEnv        ( get_env_ptr    () );
 …
 Statement * PassVisitor< pass_type >::visitStatement( Statement * stmt ) {
         return handleStatement( stmt, [this]( Statement * stmt ) {
                 maybeAccept( stmt, *this );
+                maybeAccept_impl( stmt, *this );
                 return stmt;
         });
 …
 Statement * PassVisitor< pass_type >::mutateStatement( Statement * stmt ) {
         return handleStatement( stmt, [this]( Statement * stmt ) {
+                return maybeMutate( stmt, *this );
+                maybeMutate_impl( stmt, *this );
+                return stmt;
         });
+}
 …
 template< typename func_t >
 Expression * PassVisitor< pass_type >::handleExpression( Expression * expr, func_t func ) {
+        if ( ! get_visit_children() ) return expr;
         if( !expr ) return nullptr;
 …
+        }
         // should env be cloned (or moved) onto the result of the mutate?
+        // should env be moved onto the result of the mutate?
         return func( expr );
+}
 …
 Expression * PassVisitor< pass_type >::visitExpression( Expression * expr ) {
         return handleExpression(expr, [this]( Expression * expr ) {
                 expr->accept( *this );
+                maybeAccept_impl( expr, *this );
                 return expr;
         });
 …
 Expression * PassVisitor< pass_type >::mutateExpression( Expression * expr ) {
         return handleExpression(expr, [this]( Expression * expr ) {
+                return expr->acceptMutator( *this );
+                maybeMutate_impl( expr, *this );
+                return expr;
         });
+}
+template< typename TreeType, typename VisitorType >
+inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
+        if ( ! visitor.get_visit_children() ) return;
+        auto guard = makeFuncGuard(
+                [&visitor]() { visitor.indexerScopeEnter(); },
+                [&visitor]() { visitor.indexerScopeLeave(); }
+        );
+        maybeAccept_impl( tree, visitor );
+}
+template< typename TreeType, typename MutatorType >
+inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
+        if ( ! mutator.get_visit_children() ) return;
+        auto guard = makeFuncGuard(
+                [&mutator]() { mutator.indexerScopeEnter(); },
+                [&mutator]() { mutator.indexerScopeLeave(); }
+        );
+        maybeMutate_impl( tree, mutator );
+}
 …
         indexerScopedAccept( node->type         , *this );
+        maybeAccept        ( node->init         , *this );
+        maybeAccept        ( node->bitfieldWidth, *this );
+        maybeAccept_impl   ( node->init         , *this );
+        maybeAccept_impl   ( node->bitfieldWidth, *this );
+        maybeAccept_impl   ( node->attributes   , *this );
         if ( node->name != "" ) {
 …
         indexerScopedMutate( node->type         , *this );
+        maybeMutateRef     ( node->init         , *this );
+        maybeMutateRef     ( node->bitfieldWidth, *this );
+        maybeMutate_impl   ( node->init         , *this );
+        maybeMutate_impl   ( node->bitfieldWidth, *this );
+        maybeMutate_impl   ( node->attributes   , *this );
         if ( node->name != "" ) {
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeAccept( node->type, *this );
+                maybeAccept( node->statements, *this );
+                maybeAccept_impl( node->type, *this );
+                maybeAccept_impl( node->statements, *this );
+                maybeAccept_impl( node->attributes, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
+                maybeMutateRef( node->type, *this );
+                maybeMutateRef( node->statements, *this );
+                maybeMutate_impl( node->type, *this );
+                maybeMutate_impl( node->statements, *this );
+                maybeMutate_impl( node->attributes, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->members   , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->members   , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->members   , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->members   , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->members   , *this );
+        }
 …
         // unlike structs, traits, and unions, enums inject their members into the global scope
         maybeAccept( node->parameters, *this );
         maybeAccept( node->members   , *this );
+        maybeAccept_impl( node->parameters, *this );
+        maybeAccept_impl( node->members   , *this );
         VISIT_END( node );
 …
         // unlike structs, traits, and unions, enums inject their members into the global scope
         maybeMutateRef( node->parameters, *this );
         maybeMutateRef( node->members   , *this );
+        maybeMutate_impl( node->parameters, *this );
+        maybeMutate_impl( node->members   , *this );
         MUTATE_END( Declaration, node );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->members   , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->members   , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->members   , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->base      , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->base      , *this );
+        }
 …
         indexerAddType( node );
         maybeAccept( node->assertions, *this );
+        maybeAccept_impl( node->assertions, *this );
         indexerScopedAccept( node->init, *this );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->parameters, *this );
                 maybeMutateRef( node->base      , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->base      , *this );
+        }
 …
         indexerAddType( node );
         maybeMutateRef( node->assertions, *this );
+        maybeMutate_impl( node->assertions, *this );
         indexerScopedMutate( node->init, *this );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->parameters, *this );
                 maybeAccept( node->base      , *this );
+                maybeAccept_impl( node->parameters, *this );
+                maybeAccept_impl( node->base      , *this );
+        }
         indexerAddType( node );
         maybeAccept( node->assertions, *this );
+        maybeAccept_impl( node->assertions, *this );
         VISIT_END( node );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef     ( node->parameters, *this );
                 maybeMutateRef( node->base      , *this );
+                maybeMutate_impl( node->parameters, *this );
+                maybeMutate_impl( node->base      , *this );
+        }
         indexerAddType( node );
         maybeMutateRef( node->assertions, *this );
+        maybeMutate_impl( node->assertions, *this );
         MUTATE_END( Declaration, node );
 …
         VISIT_START( node );
         maybeAccept( node->stmt, *this );
+        maybeAccept_impl( node->stmt, *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->stmt, *this );
+        maybeMutate_impl( node->stmt, *this );
         MUTATE_END( AsmDecl, node );
 …
                 // if statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 acceptAll( node->get_initialization(), *this );
                 visitExpression( node->condition );
+                maybeAccept_impl( node->get_initialization(), *this );
+                visitExpression ( node->condition );
                 node->thenPart = visitStatement( node->thenPart );
                 node->elsePart = visitStatement( node->elsePart );
 …
                 // if statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->get_initialization(), *this );
+                maybeMutate_impl( node->get_initialization(), *this );
                 node->condition = mutateExpression( node->condition );
                 node->thenPart  = mutateStatement ( node->thenPart  );
 …
                 // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->initialization, *this );
+                maybeAccept_impl( node->initialization, *this );
                 visitExpression( node->condition );
                 visitExpression( node->increment );
 …
                 // for statements introduce a level of scope (for the initialization)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->initialization, *this );
+                maybeMutate_impl( node->initialization, *this );
                 node->condition = mutateExpression( node->condition );
                 node->increment = mutateExpression( node->increment );
 …
         VISIT_START( node );
         maybeAccept( node->block       , *this );
         maybeAccept( node->handlers    , *this );
         maybeAccept( node->finallyBlock, *this );
+        maybeAccept_impl( node->block       , *this );
+        maybeAccept_impl( node->handlers    , *this );
+        maybeAccept_impl( node->finallyBlock, *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->block       , *this );
         maybeMutateRef( node->handlers    , *this );
         maybeMutateRef( node->finallyBlock, *this );
+        maybeMutate_impl( node->block       , *this );
+        maybeMutate_impl( node->handlers    , *this );
+        maybeMutate_impl( node->finallyBlock, *this );
         MUTATE_END( Statement, node );
 …
                 // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->decl, *this );
+                maybeAccept_impl( node->decl, *this );
                 node->cond = visitExpression( node->cond );
                 node->body = visitStatement ( node->body );
 …
                 // catch statements introduce a level of scope (for the caught exception)
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->decl, *this );
+                maybeMutate_impl( node->decl, *this );
                 node->cond = mutateExpression( node->cond );
                 node->body = mutateStatement ( node->body );
 …
         indexerScopedAccept( node->result  , *this );
         maybeAccept        ( node->function, *this );
         maybeAccept        ( node->args    , *this );
+        maybeAccept_impl        ( node->function, *this );
+        maybeAccept_impl        ( node->args    , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env     , *this );
         indexerScopedMutate( node->result  , *this );
         maybeMutateRef     ( node->function, *this );
         maybeMutateRef     ( node->args    , *this );
+        maybeMutate_impl   ( node->function, *this );
+        maybeMutate_impl   ( node->args    , *this );
         MUTATE_END( Expression, node );
 …
         VISIT_START( node );
         // maybeAccept( node->get_env(), *this );
+        // maybeAccept_impl( node->get_env(), *this );
         indexerScopedAccept( node->result, *this );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg   , *this );
+        maybeAccept_impl        ( node->arg   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg   , *this );
+        maybeMutate_impl   ( node->arg   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept( node->arg, *this );
+        maybeAccept_impl( node->arg, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg   , *this );
+        maybeMutate_impl   ( node->arg   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg   , *this );
+        maybeAccept_impl   ( node->arg   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg   , *this );
+        maybeMutate_impl   ( node->arg   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result   , *this );
         maybeAccept        ( node->aggregate, *this );
         maybeAccept        ( node->member   , *this );
+        maybeAccept_impl   ( node->aggregate, *this );
+        maybeAccept_impl   ( node->member   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env      , *this );
         indexerScopedMutate( node->result   , *this );
         maybeMutateRef     ( node->aggregate, *this );
         maybeMutateRef     ( node->member   , *this );
+        maybeMutate_impl   ( node->aggregate, *this );
+        maybeMutate_impl   ( node->member   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result   , *this );
         maybeAccept        ( node->aggregate, *this );
+        maybeAccept_impl   ( node->aggregate, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env      , *this );
         indexerScopedMutate( node->result   , *this );
         maybeMutateRef     ( node->aggregate, *this );
+        maybeMutate_impl   ( node->aggregate, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result   , *this );
         maybeAccept        ( &node->constant, *this );
+        maybeAccept_impl   ( &node->constant, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
+        node->constant = *maybeMutate( &node->constant, *this );
+        Constant * ptr = &node->constant;
+        maybeMutate_impl( ptr, *this );
+        node->constant = *ptr;
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         if ( node->get_isType() ) {
                 maybeAccept( node->type, *this );
+                maybeAccept_impl( node->type, *this );
         } else {
                 maybeAccept( node->expr, *this );
+                maybeAccept_impl( node->expr, *this );
+        }
 …
         indexerScopedMutate( node->result, *this );
         if ( node->get_isType() ) {
                 maybeMutateRef( node->type, *this );
+                maybeMutate_impl( node->type, *this );
         } else {
                 maybeMutateRef( node->expr, *this );
+                maybeMutate_impl( node->expr, *this );
+        }
 …
         indexerScopedAccept( node->result, *this );
         if ( node->get_isType() ) {
                 maybeAccept( node->type, *this );
+                maybeAccept_impl( node->type, *this );
         } else {
                 maybeAccept( node->expr, *this );
+                maybeAccept_impl( node->expr, *this );
+        }
 …
         indexerScopedMutate( node->result, *this );
         if ( node->get_isType() ) {
                 maybeMutateRef( node->type, *this );
+                maybeMutate_impl( node->type, *this );
         } else {
                 maybeMutateRef( node->expr, *this );
+                maybeMutate_impl( node->expr, *this );
+        }
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type  , *this );
+        maybeAccept_impl   ( node->type  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
+        maybeMutate_impl   ( node->type  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type  , *this );
         maybeAccept        ( node->member, *this );
+        maybeAccept_impl   ( node->type  , *this );
+        maybeAccept_impl   ( node->member, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
         maybeMutateRef     ( node->member, *this );
+        maybeMutate_impl   ( node->type  , *this );
+        maybeMutate_impl   ( node->member, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type  , *this );
+        maybeAccept_impl   ( node->type  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
+        maybeMutate_impl   ( node->type  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         if ( node->get_isType() ) {
                 maybeAccept( node->type, *this );
+                maybeAccept_impl( node->type, *this );
         } else {
                 maybeAccept( node->expr, *this );
+                maybeAccept_impl( node->expr, *this );
+        }
 …
         indexerScopedMutate( node->result, *this );
         if ( node->get_isType() ) {
                 maybeMutateRef( node->type, *this );
+                maybeMutate_impl( node->type, *this );
         } else {
                 maybeMutateRef( node->expr, *this );
+                maybeMutate_impl( node->expr, *this );
+        }
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg1  , *this );
         maybeAccept        ( node->arg2  , *this );
+        maybeAccept_impl   ( node->arg1  , *this );
+        maybeAccept_impl   ( node->arg2  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg1  , *this );
         maybeMutateRef     ( node->arg2  , *this );
+        maybeMutate_impl   ( node->arg1  , *this );
+        maybeMutate_impl   ( node->arg2  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg1  , *this );
         maybeAccept        ( node->arg2  , *this );
         maybeAccept        ( node->arg3  , *this );
+        maybeAccept_impl        ( node->arg1  , *this );
+        maybeAccept_impl        ( node->arg2  , *this );
+        maybeAccept_impl        ( node->arg3  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg1  , *this );
         maybeMutateRef     ( node->arg2  , *this );
         maybeMutateRef     ( node->arg3  , *this );
+        maybeMutate_impl   ( node->arg1  , *this );
+        maybeMutate_impl   ( node->arg2  , *this );
+        maybeMutate_impl   ( node->arg3  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->arg1  , *this );
         maybeAccept        ( node->arg2  , *this );
+        maybeAccept_impl   ( node->arg1  , *this );
+        maybeAccept_impl   ( node->arg2  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->arg1  , *this );
         maybeMutateRef     ( node->arg2  , *this );
+        maybeMutate_impl   ( node->arg1  , *this );
+        maybeMutate_impl   ( node->arg2  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->type, *this );
+        maybeAccept_impl   ( node->type, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->type  , *this );
+        maybeMutate_impl   ( node->type  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result    , *this );
         maybeAccept        ( node->inout     , *this );
         maybeAccept        ( node->constraint, *this );
         maybeAccept        ( node->operand   , *this );
+        maybeAccept_impl   ( node->inout     , *this );
+        maybeAccept_impl   ( node->constraint, *this );
+        maybeAccept_impl   ( node->operand   , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env       , *this );
         indexerScopedMutate( node->result    , *this );
         maybeMutateRef     ( node->inout     , *this );
         maybeMutateRef     ( node->constraint, *this );
         maybeMutateRef     ( node->operand   , *this );
+        maybeMutate_impl   ( node->inout     , *this );
+        maybeMutate_impl   ( node->constraint, *this );
+        maybeMutate_impl   ( node->operand   , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result     , *this );
         maybeAccept        ( node->callExpr   , *this );
         maybeAccept        ( node->tempDecls  , *this );
         maybeAccept        ( node->returnDecls, *this );
         maybeAccept        ( node->dtors      , *this );
+        maybeAccept_impl   ( node->callExpr   , *this );
+        maybeAccept_impl   ( node->tempDecls  , *this );
+        maybeAccept_impl   ( node->returnDecls, *this );
+        maybeAccept_impl   ( node->dtors      , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env        , *this );
         indexerScopedMutate( node->result     , *this );
         maybeMutateRef     ( node->callExpr   , *this );
         maybeMutateRef     ( node->tempDecls  , *this );
         maybeMutateRef     ( node->returnDecls, *this );
         maybeMutateRef     ( node->dtors      , *this );
+        maybeMutate_impl   ( node->callExpr   , *this );
+        maybeMutate_impl   ( node->tempDecls  , *this );
+        maybeMutate_impl   ( node->returnDecls, *this );
+        maybeMutate_impl   ( node->dtors      , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result  , *this );
         maybeAccept        ( node->callExpr, *this );
+        maybeAccept_impl   ( node->callExpr, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env     , *this );
         indexerScopedMutate( node->result  , *this );
         maybeMutateRef     ( node->callExpr, *this );
+        maybeMutate_impl   ( node->callExpr, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result     , *this );
         maybeAccept        ( node->initializer, *this );
+        maybeAccept_impl   ( node->initializer, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env        , *this );
         indexerScopedMutate( node->result     , *this );
         maybeMutateRef     ( node->initializer, *this );
+        maybeMutate_impl     ( node->initializer, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->low   , *this );
         maybeAccept        ( node->high  , *this );
+        maybeAccept_impl   ( node->low   , *this );
+        maybeAccept_impl   ( node->high  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->low   , *this );
         maybeMutateRef     ( node->high  , *this );
+        maybeMutate_impl   ( node->low   , *this );
+        maybeMutate_impl   ( node->high  , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->exprs , *this );
+        maybeAccept_impl   ( node->exprs , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->exprs , *this );
+        maybeMutate_impl   ( node->exprs , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept          ( node->exprs , *this );
+        maybeAccept_impl   ( node->exprs , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->exprs , *this );
+        maybeMutate_impl   ( node->exprs , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->tuple , *this );
+        maybeAccept_impl   ( node->tuple , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->tuple , *this );
+        maybeMutate_impl   ( node->tuple , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result  , *this );
         maybeAccept        ( node->stmtExpr, *this );
+        maybeAccept_impl   ( node->stmtExpr, *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env     , *this );
         indexerScopedMutate( node->result  , *this );
         maybeMutateRef     ( node->stmtExpr, *this );
+        maybeMutate_impl   ( node->stmtExpr, *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result     , *this );
         maybeAccept        ( node->statements , *this );
         maybeAccept        ( node->returnDecls, *this );
         maybeAccept        ( node->dtors      , *this );
+        maybeAccept_impl   ( node->statements , *this );
+        maybeAccept_impl   ( node->returnDecls, *this );
+        maybeAccept_impl   ( node->dtors      , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->result     , *this );
         maybeMutateRef     ( node->statements , *this );
         maybeMutateRef     ( node->returnDecls, *this );
         maybeMutateRef     ( node->dtors      , *this );
+        maybeMutate_impl   ( node->statements , *this );
+        maybeMutate_impl   ( node->returnDecls, *this );
+        maybeMutate_impl   ( node->dtors      , *this );
         MUTATE_END( Expression, node );
 …
         indexerScopedAccept( node->result, *this );
         maybeAccept        ( node->expr  , *this );
+        maybeAccept_impl   ( node->expr  , *this );
         VISIT_END( node );
 …
         indexerScopedMutate( node->env   , *this );
         indexerScopedMutate( node->result, *this );
         maybeMutateRef     ( node->expr  , *this );
+        maybeMutate_impl   ( node->expr  , *this );
         MUTATE_END( Expression, node );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->forall    , *this );
                 maybeAccept( node->parameters, *this );
+                maybeAccept_impl( node->forall    , *this );
+                maybeAccept_impl( node->parameters, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->forall    , *this );
                 maybeMutateRef( node->parameters, *this );
+                maybeMutate_impl( node->forall    , *this );
+                maybeMutate_impl( node->parameters, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeAccept( node->forall    , *this );
                 maybeAccept( node->parameters, *this );
+                maybeAccept_impl( node->forall    , *this );
+                maybeAccept_impl( node->parameters, *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
                 maybeMutateRef( node->forall    , *this );
                 maybeMutateRef( node->parameters, *this );
+                maybeMutate_impl( node->forall    , *this );
+                maybeMutate_impl( node->parameters, *this );
+        }
 …
         VISIT_START( node );
         maybeAccept( node->forall    , *this );
         maybeAccept( node->parameters, *this );
+        maybeAccept_impl( node->forall    , *this );
+        maybeAccept_impl( node->parameters, *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->forall    , *this );
         maybeMutateRef( node->parameters, *this );
+        maybeMutate_impl( node->forall    , *this );
+        maybeMutate_impl( node->parameters, *this );
         MUTATE_END( Type, node );
 …
         VISIT_START( node );
         maybeAccept( node->get_designators(), *this );
+        maybeAccept_impl( node->get_designators(), *this );
         VISIT_END( node );
 …
         MUTATE_START( node );
         maybeMutateRef( node->get_designators(), *this );
+        maybeMutate_impl( node->get_designators(), *this );
         MUTATE_END( Designation, node );
 …
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( Constant * node ) {
+        VISIT_BODY( node );
+}
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( Attribute * node ) {
         VISIT_BODY( node );
+}
 …
         MUTATE_BODY( Constant, node );
+}
+template< typename pass_type >
+Attribute * PassVisitor< pass_type >::mutate( Attribute * node  )  {
+        MUTATE_BODY( Attribute, node );
+}
+template< typename pass_type >
+TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
+        MUTATE_START( node );
+        for ( auto & p : node->typeEnv ) {
+                indexerScopedMutate( p.second, *this );
+        }
+        for ( auto & p : node->varEnv ) {
+                indexerScopedMutate( p.second, *this );
+        }
+        MUTATE_END( TypeSubstitution, node );
+}

src/Common/PassVisitor.proto.h

-              r78315272
+              r3f7e12cb
         ~bool_ref() = default;
         operator bool() { return *m_ref; }
+        operator bool() { return m_ref ? *m_ref : true; }
         bool operator=( bool val ) { return *m_ref = val; }
 private:
+        template<typename pass>
+        friend class PassVisitor;
+        void set( bool & val ) { m_ref = &val; };
+        bool * m_ref;
+        friend class ChildrenGuard;
+        bool * set( bool & val ) {
+                bool * prev = m_ref;
+                m_ref = &val;
+                return prev;
+        }
+        bool * m_ref = nullptr;
 };
+template< typename TreeType, typename VisitorType >
+inline void indexerScopedAccept( TreeType * tree, VisitorType & visitor ) {
+        auto guard = makeFuncGuard(
                 [&visitor]() { visitor.indexerScopeEnter(); },
                 [&visitor]() { visitor.indexerScopeLeave(); }
         );
         maybeAccept( tree, visitor );
+}
+template< typename TreeType, typename MutatorType >
 inline void indexerScopedMutate( TreeType *& tree, MutatorType & mutator ) {
         auto guard = makeFuncGuard(
                 [&mutator]() { mutator.indexerScopeEnter(); },
                 [&mutator]() { mutator.indexerScopeLeave(); }
+        );
         tree = maybeMutate( tree, mutator );
+}
+template< typename TreeType, typename MutatorType >
+inline void maybeMutateRef( TreeType *& tree, MutatorType & mutator ) {
         tree = maybeMutate( tree, mutator );
+}
+class ChildrenGuard {
+public:
+        ChildrenGuard( bool_ref * ref )
+                : m_val ( true )
+                , m_prev( ref ? ref->set( m_val ) : nullptr )
+                , m_ref ( ref )
+        {}
+        ~ChildrenGuard() {
+                if( m_ref ) {
+                        m_ref->set( *m_prev );
+                }
+        }
+        operator bool() { return m_val; }
+private:
+        bool       m_val;
+        bool     * m_prev;
+        bool_ref * m_ref;
+};
 //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------

src/Common/utility.h

-              r78315272
+              r3f7e12cb
 #include <cctype>
 #include <algorithm>
+#include <functional>
 #include <iostream>
 #include <iterator>
 …
 #include <cassert>
+#include "Common/Indenter.h"
 template< typename T >
 …
 template< typename Container >
 void printAll( const Container &container, std::ostream &os, int indent = 0 ) {
+void printAll( const Container &container, std::ostream &os, Indenter indent = {} ) {
         for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
                 if ( *i ) {
                         os << std::string( indent,  ' ' );
                         (*i)->print( os, indent + 2 );
+                        os << indent;
+                        (*i)->print( os, indent );
                         // need an endl after each element because it's not easy to know when each individual item should end
                         os << std::endl;
 …
 template< typename T1, typename T2 >
 struct group_iterate_t {
+private:
+        std::tuple<T1, T2> args;
+public:
         group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
                 assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size());
         };
+        typedef std::tuple<decltype(*std::get<0>(args).begin()), decltype(*std::get<1>(args).begin())> value_type;
+        typedef decltype(std::get<0>(args).begin()) T1Iter;
+        typedef decltype(std::get<1>(args).begin()) T2Iter;
         struct iterator {
-                typedef typename std::remove_reference<T1>::type T1val;
-                typedef typename std::remove_reference<T2>::type T2val;
-                typedef std::tuple<typename T1val::value_type &, typename T2val::value_type &> value_type;
-                typedef typename T1val::iterator T1Iter;
-                typedef typename T2val::iterator T2Iter;
                 typedef std::tuple<T1Iter, T2Iter> IterTuple;
                 IterTuple it;
 …
                 value_type operator*() const { return std::tie( *std::get<0>(it), *std::get<1>(it) ); }
         };
         iterator begin() { return iterator( std::get<0>(args).begin(), std::get<1>(args).begin() ); }
         iterator end() { return iterator( std::get<0>(args).end(), std::get<1>(args).end() ); }
-private:
-        std::tuple<T1, T2> args;
 };

src/Concurrency/Keywords.cc

-              r78315272
+              r3f7e12cb
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
                 void validate( DeclarationWithType * );
+                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
                 void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
 …
                 StructDecl* monitor_decl = nullptr;
                 StructDecl* guard_decl = nullptr;
+                StructDecl* dtor_guard_decl = nullptr;
                 static std::unique_ptr< Type > generic_func;
 …
                 void postvisit( FunctionDecl * decl );
+                void previsit ( StructDecl   * decl );
                 void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
 …
                         acceptAll( translationUnit, impl );
+                }
+          private :
+                bool thread_ctor_seen = false;
+                StructDecl * thread_decl = nullptr;
         };
 …
                 if( mutexArgs.empty() ) return;
+                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl );
+                bool isDtor = CodeGen::isDestructor( decl->name );
+                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl );
                 for(auto arg : mutexArgs) {
                         validate( arg );
 …
                 if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
                 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                addStatments( decl, body, mutexArgs );
+                if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                if( isDtor ) {
+                        addDtorStatments( decl, body, mutexArgs );
+                }
+                else {
+                        addStatments( decl, body, mutexArgs );
+                }
+        }
 …
                         assert( !guard_decl );
                         guard_decl = decl;
+                }
+                else if( decl->name == "monitor_dtor_guard_t" ) {
+                        assert( !dtor_guard_decl );
+                        dtor_guard_decl = decl;
+                }
+        }
 …
                 //Make sure that typed isn't mutex
                 if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+        }
+        void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+                Type * arg_type = args.front()->get_type()->clone();
+                arg_type->set_mutex( false );
+                ObjectDecl * monitors = new ObjectDecl(
+                        "__monitor",
+                        noStorage,
+                        LinkageSpec::Cforall,
+                        nullptr,
+                        new PointerType(
+                                noQualifiers,
+                                new StructInstType(
+                                        noQualifiers,
+                                        monitor_decl
+                                )
+                        ),
+                        new SingleInit( new UntypedExpr(
+                                new NameExpr( "get_monitor" ),
+                                {  new CastExpr( new VariableExpr( args.front() ), arg_type ) }
+                        ))
+                );
+                assert(generic_func);
+                //in reverse order :
+                // monitor_guard_t __guard = { __monitors, #, func };
+                body->push_front(
+                        new DeclStmt( noLabels, new ObjectDecl(
+                                "__guard",
+                                noStorage,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        dtor_guard_decl
+                                ),
+                                new ListInit(
+                                        {
+                                                new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
+                body->push_front( new DeclStmt( noLabels, monitors) );
+        }
 …
         // General entry routine
         //=============================================================================================
+        void ThreadStarter::previsit( StructDecl * decl ) {
+                if( decl->name == "thread_desc" && decl->body ) {
+                        assert( !thread_decl );
+                        thread_decl = decl;
+                }
+        }
         void ThreadStarter::postvisit(FunctionDecl * decl) {
                 if( ! CodeGen::isConstructor(decl->name) ) return;
+                Type * typeof_this = InitTweak::getTypeofThis(decl->type);
+                StructInstType * ctored_type = dynamic_cast< StructInstType * >( typeof_this );
+                if( ctored_type && ctored_type->baseStruct == thread_decl ) {
+                        thread_ctor_seen = true;
+                }
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
                 auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
-                // if( type ) std::cerr << "FRED2" << std::endl;
                 if( type && type->get_baseStruct()->is_thread() ) {
+                        if( !thread_decl || !thread_ctor_seen ) {
+                                throw SemanticError("thread keyword requires threads to be in scope, add #include <thread>");
+                        }
                         addStartStatement( decl, param );
+                }

src/Concurrency/Waitfor.cc

-              r78315272
+              r3f7e12cb
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
+#include "ResolvExpr/Resolver.h"   // for findVoidExpression
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
 …
         //=============================================================================================
         class GenerateWaitForPass final : public WithStmtsToAdd {
+        class GenerateWaitForPass final : public WithIndexer {
           public:
 …
                 ObjectDecl * declare( unsigned long count, CompoundStmt * stmt );
+                ObjectDecl * declareFlag( CompoundStmt * stmt );
+                Statement  * makeSetter( ObjectDecl * flag );
                 ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt );
                 void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt );
                 Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt );
                 Expression * call();
                 void choose();
+                void         init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt );
+                Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt );
+                Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt);
+                void         choose( WaitForStmt * waitfor, Expression  * result, CompoundStmt * stmt );
                 static void implement( std::list< Declaration * > & translationUnit ) {
 …
           private:
                 FunctionDecl        * decl_waitfor    = nullptr;
+                StructDecl          * decl_mask       = nullptr;
                 StructDecl          * decl_acceptable = nullptr;
                 StructDecl          * decl_monitor    = nullptr;
-                DeclarationWithType * decl_m_func     = nullptr;
-                DeclarationWithType * decl_m_count    = nullptr;
-                DeclarationWithType * decl_m_monitors = nullptr;
-                DeclarationWithType * decl_m_isdtor   = nullptr;
                 static std::unique_ptr< Type > generic_func;
+                UniqueName namer_acc = "__acceptables_"s;
+                UniqueName namer_idx = "__index_"s;
+                UniqueName namer_flg = "__do_run_"s;
+                UniqueName namer_msk = "__mask_"s;
                 UniqueName namer_mon = "__monitors_"s;
-                UniqueName namer_acc = "__acceptables_"s;
                 UniqueName namer_tim = "__timeout_"s;
         };
 …
         namespace {
                 Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) {
                         return new ApplicationExpr(
+                        return new UntypedExpr(
                                 new NameExpr( "?[?]" ),
+                                {
 …
                 Expression * makeOpAssign( Expression * lhs, Expression * rhs ) {
                         return new ApplicationExpr(
+                        return new UntypedExpr(
                                         new NameExpr( "?=?" ),
                                         { lhs, rhs }
 …
+                }
+                Expression * makeOpMember( Expression * sue, DeclarationWithType * mem ) {
+                        return new MemberExpr( mem, sue );
+                }
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, DeclarationWithType * member, Expression * value ) {
+                        return new ExprStmt(
+                                noLabels,
+                                makeOpAssign(
+                                        makeOpMember(
+                                                makeOpIndex(
+                                                        object,
+                                                        index
+                                                ),
+                                                member
+                Expression * makeOpMember( Expression * sue, const std::string & mem ) {
+                        return new UntypedMemberExpr( new NameExpr( mem ), sue );
+                }
+                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
+                        Expression * expr = makeOpAssign(
+                                makeOpMember(
+                                        makeOpIndex(
+                                                object,
+                                                index
                                         ),
+                                        value
+                                )
+                                        member
+                                ),
+                                value
                         );
+                        ResolvExpr::findVoidExpression( expr, indexer );
+                        return new ExprStmt( noLabels, expr );
+                }
 …
                         return new ConstantExpr( Constant::from_bool( ifnull ) );
+                }
+                VariableExpr * extractVariable( Expression * func ) {
+                        if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) {
+                                return var;
+                        }
+                        CastExpr * cast = strict_dynamic_cast< CastExpr * >( func );
+                        return strict_dynamic_cast< VariableExpr * >( cast->arg );
+                }
+                Expression * detectIsDtor( Expression * func ) {
+                        VariableExpr * typed_func = extractVariable( func );
+                        bool is_dtor = InitTweak::isDestructor( typed_func->var );
+                        return new ConstantExpr( Constant::from_bool( is_dtor ) );
+                }
         };
 …
         void GenerateWaitForPass::premutate( FunctionDecl * decl) {
                 if( decl->name != "__accept_internal" ) return;
+                if( decl->name != "__waitfor_internal" ) return;
                 decl_waitfor = decl;
 …
                         assert( !decl_acceptable );
                         decl_acceptable = decl;
+                        for( Declaration * field : decl_acceptable->members ) {
+                                     if( field->name == "func"    ) decl_m_func     = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "count"   ) decl_m_count    = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field );
+                                else if( field->name == "is_dtor" ) decl_m_isdtor   = strict_dynamic_cast< DeclarationWithType * >( field );
+                        }
+                }
+                else if( decl->name == "__waitfor_mask_t" ) {
+                        assert( !decl_mask );
+                        decl_mask = decl;
+                }
                 else if( decl->name == "monitor_desc" ) {
 …
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
+                return waitfor;
+                if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
                 CompoundStmt * stmt = new CompoundStmt( noLabels );
                 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
+                ObjectDecl * flag        = declareFlag( stmt );
+                Statement  * setter      = makeSetter( flag );
                 int index = 0;
                 for( auto & clause : waitfor->clauses ) {
                         init( acceptables, index, clause, stmt );
+                        init( acceptables, index, clause, setter, stmt );
                         index++;
 …
                         waitfor->orelse .statement,
                         waitfor->orelse .condition,
+                        setter,
                         stmt
                 );
+                // Expression * result  = call( acceptables, timeout, orelse, stmt );
+                // choose( waitfor, result );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                stmt->push_back( new IfStmt(
+                        noLabels,
+                        safeCond( new VariableExpr( flag ) ),
+                        compound,
+                        nullptr
+                ));
+                Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound );
+                choose( waitfor, result, compound );
                 return stmt;
 …
         ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt )
+        {
                 ObjectDecl * acceptables = new ObjectDecl(
+                ObjectDecl * acceptables = ObjectDecl::newObject(
                         namer_acc.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
 …
                 stmt->push_back( new DeclStmt( noLabels, acceptables) );
+                Expression * set = new UntypedExpr(
+                        new NameExpr( "__builtin_memset" ),
+                        {
+                                new VariableExpr( acceptables ),
+                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                new SizeofExpr( new VariableExpr( acceptables ) )
+                        }
+                );
+                ResolvExpr::findVoidExpression( set, indexer );
+                stmt->push_back( new ExprStmt( noLabels, set ) );
                 return acceptables;
+        }
+        ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) {
+                ObjectDecl * flag = ObjectDecl::newObject(
+                        namer_flg.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::Bool
+                        ),
+                        new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) )
+                );
+                stmt->push_back( new DeclStmt( noLabels, flag) );
+                return flag;
+        }
+        Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
+                Expression * expr = new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new VariableExpr( flag ),
+                                new ConstantExpr( Constant::from_ulong( 1 ) )
+                        }
+                );
+                ResolvExpr::findVoidExpression( expr, indexer );
+                return new ExprStmt( noLabels, expr );
+        }
         ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
                 ObjectDecl * mon = new ObjectDecl(
+                ObjectDecl * mon = ObjectDecl::newObject(
                         namer_mon.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new ArrayType(
                                 noQualifiers,
                                 new StructInstType(
+                                new PointerType(
                                         noQualifiers,
+                                        decl_monitor
+                                        new StructInstType(
+                                                noQualifiers,
+                                                decl_monitor
+                                        )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ),
 …
                         new ListInit(
                                 map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
+                                        return new SingleInit( expr );
+                                        Expression * init = new CastExpr(
+                                                new UntypedExpr(
+                                                        new NameExpr( "get_monitor" ),
+                                                        { expr }
+                                                ),
+                                                new PointerType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_monitor
+                                                        )
+                                                )
+                                        );
+                                        ResolvExpr::findSingleExpression( init, indexer );
+                                        return new SingleInit( init );
                                 })
+                        )
 …
+        }
         void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) {
+        void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) {
                 ObjectDecl * monitors = declMon( clause, stmt );
+                CompoundStmt * compound = new CompoundStmt( noLabels );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_func    , clause.target.function ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_count   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ) ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_monitors, new VariableExpr( monitors ) ) );
+                compound->push_back( makeAccStatement( acceptables, index, decl_m_isdtor  , new ConstantExpr( Constant::from_bool( true ) ) ) );
+                Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) );
                 stmt->push_back( new IfStmt(
                         noLabels,
                         safeCond( clause.condition ),
+                        compound,
+                        new CompoundStmt({
+                                makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "list"   , new VariableExpr( monitors )                                              , indexer ),
+                                makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
+                                setter->clone()
+                        }),
                         nullptr
                 ));
 …
                 bool has_else,
                 Expression *& else_cond,
+                Statement * setter,
                 CompoundStmt * stmt
         ) {
                 ObjectDecl * timeout = new ObjectDecl(
+                ObjectDecl * timeout = ObjectDecl::newObject(
                         namer_tim.newName(),
-                        noStorage,
-                        LinkageSpec::Cforall,
-                        nullptr,
                         new BasicType(
                                 noQualifiers,
 …
                         stmt->push_back( new IfStmt(
                                 noLabels,
+                                safeCond( else_cond ),
+                                new ExprStmt(
+                                        noLabels,
+                                        makeOpAssign(
+                                                new VariableExpr( timeout ),
+                                                time
+                                        )
+                                ),
+                                safeCond( time_cond ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        time
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
 …
                                 noLabels,
                                 safeCond( else_cond ),
+                                new ExprStmt(
+                                        noLabels,
+                                        makeOpAssign(
+                                                new VariableExpr( timeout ),
+                                                new ConstantExpr( Constant::from_ulong( 0 ) )
+                                        )
+                                ),
+                                new CompoundStmt({
+                                        new ExprStmt(
+                                                noLabels,
+                                                makeOpAssign(
+                                                        new VariableExpr( timeout ),
+                                                        new ConstantExpr( Constant::from_ulong( 0 ) )
+                                                )
+                                        ),
+                                        setter->clone()
+                                }),
                                 nullptr
                         ));
 …
+                }
+                delete setter;
                 return new VariableExpr( timeout );
+        }
+        Expression * GenerateWaitForPass::call(
+                size_t count,
+                ObjectDecl * acceptables,
+                Expression * timeout,
+                CompoundStmt * stmt
+        ) {
+                ObjectDecl * index = ObjectDecl::newObject(
+                        namer_idx.newName(),
+                        new BasicType(
+                                noQualifiers,
+                                BasicType::ShortSignedInt
+                        ),
+                        new SingleInit(
+                                new ConstantExpr( Constant::from_int( -1 ) )
+                        )
+                );
+                stmt->push_back( new DeclStmt( noLabels, index ) );
+                ObjectDecl * mask = ObjectDecl::newObject(
+                        namer_msk.newName(),
+                        new StructInstType(
+                                noQualifiers,
+                                decl_mask
+                        ),
+                        new ListInit({
+                                new SingleInit( new AddressExpr( new VariableExpr( index ) ) ),
+                                new SingleInit( new VariableExpr( acceptables ) ),
+                                new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) )
+                        })
+                );
+                stmt->push_back( new DeclStmt( noLabels, mask ) );
+                stmt->push_back( new ExprStmt(
+                        noLabels,
+                        new ApplicationExpr(
+                                VariableExpr::functionPointer( decl_waitfor ),
+                                {
+                                        new CastExpr(
+                                                new VariableExpr( mask ),
+                                                new ReferenceType(
+                                                        noQualifiers,
+                                                        new StructInstType(
+                                                                noQualifiers,
+                                                                decl_mask
+                                                        )
+                                                )
+                                        ),
+                                        timeout
+                                }
+                        )
+                ));
+                return new VariableExpr( index );
+        }
+        void GenerateWaitForPass::choose(
+                WaitForStmt * waitfor,
+                Expression  * result,
+                CompoundStmt * stmt
+        ) {
+                SwitchStmt * swtch = new SwitchStmt(
+                        noLabels,
+                        result,
+                        std::list<Statement *>()
+                );
+                unsigned long i = 0;
+                for( auto & clause : waitfor->clauses ) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_ulong( i++ ) ),
+                                        {
+                                                clause.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                if(waitfor->timeout.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -2 ) ),
+                                        {
+                                                waitfor->timeout.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                if(waitfor->orelse.statement) {
+                        swtch->statements.push_back(
+                                new CaseStmt(
+                                        noLabels,
+                                        new ConstantExpr( Constant::from_int( -1 ) ),
+                                        {
+                                                waitfor->orelse.statement,
+                                                new BranchStmt(
+                                                        noLabels,
+                                                        "",
+                                                        BranchStmt::Break
+                                                )
+                                        }
+                                )
+                        );
+                }
+                stmt->push_back( swtch );
+        }
 };

src/GenPoly/Box.cc

-              r78315272
+              r3f7e12cb
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for toString
-#include "DeclMutator.h"                 // for DeclMutator
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
 …
 #include "Lvalue.h"                      // for generalizedLvalue
 #include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
 …
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
+                class BoxPass {
+                protected:
+                        BoxPass() : scopeTyVars( TypeDecl::Data{} ) {}
+                        TyVarMap scopeTyVars;
+                };
                 /// Adds layout-generation functions to polymorphic types
                 class LayoutFunctionBuilder final : public DeclMutator {
                         unsigned int functionNesting;  // current level of nested functions
+                class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
+                        unsigned int functionNesting = 0;  // current level of nested functions
                 public:
+                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
+                        using DeclMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        void previsit( FunctionDecl *functionDecl );
+                        void previsit( StructDecl *structDecl );
+                        void previsit( UnionDecl *unionDecl );
                 };
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 final : public PolyMutator {
+                class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
                   public:
                         Pass1();
+                        using PolyMutator::mutate;
+                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
+                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
+                        virtual Expression *mutate( UntypedExpr *expr ) override;
+                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
+                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
+                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type * mutate( FunctionType *functionType ) override;
+                        virtual void doBeginScope() override;
+                        virtual void doEndScope() override;
+                        void premutate( FunctionDecl * functionDecl );
+                        void premutate( TypeDecl * typeDecl );
+                        void premutate( CommaExpr * commaExpr );
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                        Expression * postmutate( UntypedExpr *expr );
+                        void premutate( AddressExpr * addrExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                        void premutate( ReturnStmt * returnStmt );
+                        void premutate( PointerType * pointerType );
+                        void premutate( FunctionType * functionType );
+                        void beginScope();
+                        void endScope();
                   private:
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
 …
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
+                class Pass2 final : public PolyMutator {
+                  public:
+                        template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl );
+                        template< typename AggDecl >
+                        AggDecl * handleAggDecl( AggDecl * aggDecl );
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
+                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
+                        virtual TraitDecl *mutate( TraitDecl *unionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                struct Pass2 final : public BoxPass, public WithGuards {
+                        void handleAggDecl();
+                        DeclarationWithType * postmutate( FunctionDecl *functionDecl );
+                        void premutate( StructDecl *structDecl );
+                        void premutate( UnionDecl *unionDecl );
+                        void premutate( TraitDecl *unionDecl );
+                        void premutate( TypeDecl *typeDecl );
+                        void premutate( PointerType *pointerType );
+                        void premutate( FunctionType *funcType );
                   private:
 …
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
                 class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
+                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
                         PolyGenericCalculator();
 …
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
-                        TyVarMap scopeTyVars;
                 };
                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
+                class Pass3 final : public PolyMutator {
+                  public:
+                struct Pass3 final : public BoxPass, public WithGuards {
                         template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+                        using PolyMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                  private:
+                        void handleDecl( DeclClass * decl, Type * type );
+                        void premutate( ObjectDecl * objectDecl );
+                        void premutate( FunctionDecl * functionDecl );
+                        void premutate( TypedefDecl * typedefDecl );
+                        void premutate( StructDecl * structDecl );
+                        void premutate( UnionDecl * unionDecl );
+                        void premutate( TypeDecl * typeDecl );
+                        void premutate( PointerType * pointerType );
+                        void premutate( FunctionType * funcType );
                 };
         } // anonymous namespace
 …
         void box( std::list< Declaration *>& translationUnit ) {
                 LayoutFunctionBuilder layoutBuilder;
                 Pass1 pass1;
                 Pass2 pass2;
+                PassVisitor<LayoutFunctionBuilder> layoutBuilder;
+                PassVisitor<Pass1> pass1;
+                PassVisitor<Pass2> pass2;
                 PassVisitor<PolyGenericCalculator> polyCalculator;
                 Pass3 pass3;
                 layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
+                PassVisitor<Pass3> pass3;
+                acceptAll( translationUnit, layoutBuilder );
+                mutateAll( translationUnit, pass1 );
+                mutateAll( translationUnit, pass2 );
                 mutateAll( translationUnit, polyCalculator );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
+                mutateAll( translationUnit, pass3 );
+        }
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
+        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->get_functionType(), *visitor );
                 ++functionNesting;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->get_statements(), *visitor );
                 --functionNesting;
-                return functionDecl;
+        }
 …
+        }
         Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
+        void LayoutFunctionBuilder::previsit( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
+                if ( structDecl->get_members().empty() ) return structDecl;
+                visit_children = false;
+                if ( structDecl->get_members().empty() ) return;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
                 if ( otypeParams.empty() ) return structDecl;
+                if ( otypeParams.empty() ) return;
                 // build layout function signature
 …
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
+                addDeclarationAfter( layoutDecl );
+                return structDecl;
+                declsToAddAfter.push_back( layoutDecl );
+        }
         Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
+        void LayoutFunctionBuilder::previsit( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
+                if ( unionDecl->get_members().empty() ) return unionDecl;
+                visit_children = false;
+                if ( unionDecl->get_members().empty() ) return;
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
                 if ( otypeParams.empty() ) return unionDecl;
+                if ( otypeParams.empty() ) return;
                 // build layout function signature
 …
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
+                addDeclarationAfter( layoutDecl );
+                return unionDecl;
+                declsToAddAfter.push_back( layoutDecl );
+        }
 …
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
+                void Pass1::premutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
+                                doBeginScope();
+                                scopeTyVars.beginScope();
+                                DeclarationWithType *oldRetval = retval;
+                                GuardScope( scopeTyVars );
+                                GuardValue( retval );
                                 // process polymorphic return value
                                 retval = nullptr;
+                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) {
+                                        retval = functionDecl->get_functionType()->get_returnVals().front();
+                                FunctionType *functionType = functionDecl->type;
+                                if ( isDynRet( functionType ) && functionDecl->linkage != LinkageSpec::C ) {
+                                        retval = functionType->returnVals.front();
                                         // give names to unnamed return values
                                         if ( retval->get_name() == "" ) {
                                                 retval->set_name( "_retparm" );
                                                 retval->set_linkage( LinkageSpec::C );
+                                        if ( retval->name == "" ) {
+                                                retval->name = "_retparm";
+                                                retval->linkage = LinkageSpec::C;
                                         } // if
                                 } // if
+                                FunctionType *functionType = functionDecl->get_functionType();
+                                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
+                                std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
+                                makeTyVarMap( functionType, scopeTyVars );
+                                std::list< DeclarationWithType *> &paramList = functionType->parameters;
                                 std::list< FunctionType *> functions;
                                 for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                         for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+                                for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) {
+                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
                                                 findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
                                         } // for
 …
                                         } // if
                                 } // for
-                                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
-                                scopeTyVars.endScope();
-                                retval = oldRetval;
-                                doEndScope();
                                 // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
+                        return functionDecl;
+                }
+                TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
+                }
+                void Pass1::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+                Expression *Pass1::mutate( CommaExpr *commaExpr ) {
+                }
+                void Pass1::premutate( CommaExpr *commaExpr ) {
                         // Attempting to find application expressions that were mutated by the copy constructor passes
                         // to use an explicit return variable, so that the variable can be reused as a parameter to the
 …
+                                }
+                        }
-                        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
-                        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
-                        return commaExpr;
+                }
-                Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
-                        condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
-                        condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
-                        condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
-                        return condExpr;
+                }
 …
                         // add size/align for generic types to parameter list
                         if ( ! appExpr->get_function()->has_result() ) return;
+                        if ( ! appExpr->get_function()->result ) return;
                         FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
                         assert( funcType );
 …
                 ObjectDecl *Pass1::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
                         stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
+                }
 …
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
+                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
+                        if ( isPolyType( param, exprTyVars ) ) {
+                                Type * newType = arg->get_result()->clone();
+                        assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
+                        if ( ! needsBoxing( param, arg->result, exprTyVars, env ) ) return;
+                        if ( arg->result->get_lvalue() ) {
+                                // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                //              return;
+                                //      }
+                                // }
+                                arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                        // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                        arg = new CastExpr( arg, param->clone() );
+                                }
+                        } else {
+                                // use type computed in unification to declare boxed variables
+                                Type * newType = param->clone();
                                 if ( env ) env->apply( newType );
+                                std::unique_ptr<Type> manager( newType );
+                                if ( isPolyType( newType ) ) {
+                                        // if the argument's type is polymorphic, we don't need to box again!
+                                        return;
+                                } else if ( arg->get_result()->get_lvalue() ) {
+                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        // if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( arg ) ) {
+                                        //      if ( dynamic_cast<ArrayType *>( varExpr->var->get_type() ) ){
+                                        //              // temporary hack - don't box arrays, because &arr is not the same as &arr[0]
+                                        //              return;
+                                        //      }
+                                        // }
+                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
+                                        if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                                // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                                arg = new CastExpr( arg, param->clone() );
+                                        }
+                                } else {
+                                        // use type computed in unification to declare boxed variables
+                                        Type * newType = param->clone();
+                                        if ( env ) env->apply( newType );
+                                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
+                                        newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
+                                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
+                                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
+                                        assign->get_args().push_back( new VariableExpr( newObj ) );
+                                        assign->get_args().push_back( arg );
+                                        stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
+                                        arg = new AddressExpr( new VariableExpr( newObj ) );
+                                } // if
+                                ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
+                                newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+                                UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
+                                assign->get_args().push_back( new VariableExpr( newObj ) );
+                                assign->get_args().push_back( arg );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
+                                arg = new AddressExpr( new VariableExpr( newObj ) );
                         } // if
+                }
+                // find instances of polymorphic type parameters
+                struct PolyFinder {
+                        const TyVarMap * tyVars = nullptr;
+                        bool found = false;
+                        void previsit( TypeInstType * t ) {
+                                if ( isPolyType( t, *tyVars ) ) {
+                                        found = true;
+                                }
+                        }
+                };
+                // true if there is an instance of a polymorphic type parameter in t
+                bool hasPolymorphism( Type * t, const TyVarMap &tyVars ) {
+                        PassVisitor<PolyFinder> finder;
+                        finder.pass.tyVars = &tyVars;
+                        maybeAccept( t, finder );
+                        return finder.pass.found;
+                }
 …
                 /// this gets rid of warnings from gcc.
                 void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
+                        if ( getFunctionType( formal ) ) {
+                        // type contains polymorphism, but isn't exactly a polytype, in which case it
+                        // has some real actual type (e.g. unsigned int) and casting to void * is wrong
+                        if ( hasPolymorphism( formal, tyVars ) && ! isPolyType( formal, tyVars ) ) {
                                 Type * newType = formal->clone();
                                 newType = ScrubTyVars::scrub( newType, tyVars );
 …
                 void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
                                 assertf( arg != appExpr->get_args().end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
+                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) {
+                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
                                 addCast( *arg, (*param)->get_type(), exprTyVars );
                                 boxParam( (*param)->get_type(), *arg, exprTyVars );
 …
                         std::list< Expression *>::iterator cur = arg;
                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
+                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
                                         InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
+                                        if ( inferParam == appExpr->get_inferParams().end() ) {
+                                                std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl;
+                                        }
+                                        assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" );
+                                        assertf( inferParam != appExpr->get_inferParams().end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
                                         Expression *newExpr = inferParam->second.expr->clone();
                                         addCast( newExpr, (*assert)->get_type(), tyVars );
 …
                 void makeRetParm( FunctionType *funcType ) {
                         DeclarationWithType *retParm = funcType->get_returnVals().front();
+                        DeclarationWithType *retParm = funcType->returnVals.front();
                         // make a new parameter that is a pointer to the type of the old return value
 …
                         // actually make the adapter type
                         FunctionType *adapter = adaptee->clone();
-//                      if ( ! adapter->get_returnVals().empty() && isPolyType( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
                         if ( isDynRet( adapter, tyVars ) ) {
                                 makeRetParm( adapter );
 …
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
                                                 stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
                                         } // if
                                         assert( adapter != adapters.end() );
 …
                                 if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
                                         if ( varExpr->get_var()->get_name() == "?[?]" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "*?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( ! appExpr->get_args().empty() );
                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 1 );
                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 1 );
                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
 …
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
                                                 assert( appExpr->has_result() );
+                                                assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
                                                 Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
 …
+                }
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
+                Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
 …
                         // }
                         // std::cerr << "\n";
+                        appExpr->get_function()->acceptMutator( *this );
+                        mutateAll( appExpr->get_args(), *this );
+                        assert( appExpr->get_function()->has_result() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
+                        assert( appExpr->function->result );
+                        FunctionType * function = getFunctionType( appExpr->function->result );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
 …
+                }
                 Expression *Pass1::mutate( UntypedExpr *expr ) {
                         if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
+                Expression * Pass1::postmutate( UntypedExpr *expr ) {
+                        if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
+                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
                                         if ( name->get_name() == "*?" ) {
                                                 Expression *ret = expr->get_args().front();
                                                 expr->get_args().clear();
+                                                Expression *ret = expr->args.front();
+                                                expr->args.clear();
                                                 delete expr;
                                                 return ret->acceptMutator( *this );
+                                                return ret;
                                         } // if
                                 } // if
                         } // if
+                        return PolyMutator::mutate( expr );
+                }
+                Expression *Pass1::mutate( AddressExpr *addrExpr ) {
+                        assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
+                        return expr;
+                }
+                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
+                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
+                        assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() );
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
                                 if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                                if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
                                         if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                                 if ( name->get_name() == "*?" ) {
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
                                                                 assert( appExpr->get_function()->has_result() );
+                                                                assert( appExpr->get_function()->result );
                                                                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
                                                                 assert( function );
 …
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
+                        addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor );
                         // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
 …
+                }
+                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->get_expr() ) {
+                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                delete returnStmt->get_expr();
+                                returnStmt->set_expr( 0 );
+                        } else {
+                                returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) );
+                void Pass1::premutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->expr ) {
+                                assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
+                                delete returnStmt->expr;
+                                returnStmt->expr = nullptr;
                         } // if
+                        return returnStmt;
+                }
+                Type * Pass1::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass1::premutate( PointerType *pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Mutator::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type * Pass1::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass1::premutate( FunctionType *functionType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
+                        Type *ret = Mutator::mutate( functionType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                void Pass1::doBeginScope() {
+                }
+                void Pass1::beginScope() {
                         adapters.beginScope();
+                }
                 void Pass1::doEndScope() {
+                void Pass1::endScope() {
                         adapters.endScope();
+                }
 …
+                }
+                template< typename DeclClass >
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
+                        return ret;
+                }
+                DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
+                        functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
+                DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
 …
+                }
+                ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl );
+                }
+                template< typename AggDecl >
+                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
+                void Pass2::premutate( StructDecl * ) {
                         // prevent tyVars from leaking into containing scope
+                        scopeTyVars.beginScope();
+                        Parent::mutate( aggDecl );
+                        scopeTyVars.endScope();
+                        return aggDecl;
+                }
+                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                TraitDecl * Pass2::mutate( TraitDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+                TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( UnionDecl * ) {
+                        // prevent tyVars from leaking into containing scope
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( TraitDecl * ) {
+                        // prevent tyVars from leaking into containing scope
+                        GuardScope( scopeTyVars );
+                }
+                void Pass2::premutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        if ( typeDecl->get_base() ) {
+                                return handleDecl( typeDecl );
+                        } else {
+                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
+                        }
+                }
+                TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl );
+                }
+                Type * Pass2::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass2::premutate( PointerType *pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Parent::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type *Pass2::mutate( FunctionType *funcType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass2::premutate( FunctionType *funcType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( funcType, scopeTyVars );
 …
                                 // move all assertions into parameter list
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
-//      *assert = (*assert)->acceptMutator( *this );
                                         // assertion parameters may not be used in body, pass along with unused attribute.
                                         (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
 …
+                                                }
+                                        }
                                         seenTypes.insert( typeName );
+                                }
 …
                         funcType->get_parameters().splice( last, inferredParams );
                         addAdapters( funcType );
-                        mutateAll( funcType->get_returnVals(), *this );
-                        mutateAll( funcType->get_parameters(), *this );
-                        scopeTyVars.endScope();
-                        return funcType;
+                }
 …
                 PolyGenericCalculator::PolyGenericCalculator()
                         : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
+                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
 …
                 template< typename DeclClass >
                 DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
                         scopeTyVars.beginScope();
+                void Pass3::handleDecl( DeclClass * decl, Type * type ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( type, scopeTyVars );
-                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
-                        // ScrubTyVars::scrub( decl, scopeTyVars );
                         ScrubTyVars::scrubAll( decl );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl, objectDecl->get_type() );
+                }
+                DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) {
+                        return handleDecl( functionDecl, functionDecl->get_functionType() );
+                }
+                TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl, typedefDecl->get_base() );
+                }
+                void Pass3::premutate( ObjectDecl * objectDecl ) {
+                        handleDecl( objectDecl, objectDecl->type );
+                }
+                void Pass3::premutate( FunctionDecl * functionDecl ) {
+                        handleDecl( functionDecl, functionDecl->type );
+                }
+                void Pass3::premutate( TypedefDecl * typedefDecl ) {
+                        handleDecl( typedefDecl, typedefDecl->base );
+                }
                 /// Strips the members from a generic aggregate
                 void stripGenericMembers(AggregateDecl* decl) {
                         if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
                 Declaration *Pass3::mutate( StructDecl *structDecl ) {
+                void stripGenericMembers(AggregateDecl * decl) {
+                        if ( ! decl->parameters.empty() ) decl->members.clear();
+                }
+                void Pass3::premutate( StructDecl * structDecl ) {
                         stripGenericMembers( structDecl );
+                        return structDecl;
+                }
+                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
+                }
+                void Pass3::premutate( UnionDecl * unionDecl ) {
                         stripGenericMembers( unionDecl );
+                        return unionDecl;
+                }
+                TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
+//   Initializer *init = 0;
+//   std::list< Expression *> designators;
+//   addToTyVarMap( typeDecl, scopeTyVars );
+//   if ( typeDecl->get_base() ) {
+//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
+//   }
+//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
+                }
+                void Pass3::premutate( TypeDecl * typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+                Type * Pass3::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass3::premutate( PointerType * pointerType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( pointerType, scopeTyVars );
+                        Type *ret = Mutator::mutate( pointerType );
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+                Type * Pass3::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
+                }
+                void Pass3::premutate( FunctionType * functionType ) {
+                        GuardScope( scopeTyVars );
                         makeTyVarMap( functionType, scopeTyVars );
-                        Type *ret = Mutator::mutate( functionType );
-                        scopeTyVars.endScope();
-                        return ret;
+                }
         } // anonymous namespace

src/GenPoly/FindFunction.cc

-              r78315272
+              r3f7e12cb
 #include <utility>                      // for pair
+#include "Common/PassVisitor.h"         // for PassVisitor
 #include "Common/SemanticError.h"       // for SemanticError
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 …
 namespace GenPoly {
         class FindFunction : public Mutator {
+        class FindFunction : public WithGuards, public WithVisitorRef<FindFunction>, public WithShortCircuiting {
           public:
                 FindFunction( std::list< FunctionType* > &functions, const TyVarMap &tyVars, bool replaceMode, FindFunctionPredicate predicate );
+                virtual Type *mutate( FunctionType *functionType );
+                virtual Type *mutate( PointerType *pointerType );
+                void premutate( FunctionType * functionType );
+                Type * postmutate( FunctionType * functionType );
+                void premutate( PointerType * pointerType );
           private:
                 void handleForall( const Type::ForallList &forall );
 …
         void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
                 FindFunction finder( functions, tyVars, false, predicate );
+                PassVisitor<FindFunction> finder( functions, tyVars, false, predicate );
                 type->acceptMutator( finder );
+        }
         void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate ) {
                 FindFunction finder( functions, tyVars, true, predicate );
+                PassVisitor<FindFunction> finder( functions, tyVars, true, predicate );
                 type = type->acceptMutator( finder );
+        }
 …
         void FindFunction::handleForall( const Type::ForallList &forall ) {
                 for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
                         TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
+                for ( const Declaration * td : forall ) {
+                        TyVarMap::iterator var = tyVars.find( td->name );
                         if ( var != tyVars.end() ) {
                                 tyVars.erase( var->first );
 …
+        }
+        Type * FindFunction::mutate( FunctionType *functionType ) {
+                tyVars.beginScope();
+        void FindFunction::premutate( FunctionType * functionType ) {
+                visit_children = false;
+                GuardScope( tyVars );
                 handleForall( functionType->get_forall() );
+                mutateAll( functionType->get_returnVals(), *this );
+                mutateAll( functionType->get_returnVals(), *visitor );
+        }
+        Type * FindFunction::postmutate( FunctionType * functionType ) {
                 Type *ret = functionType;
                 if ( predicate( functionType, tyVars ) ) {
 …
                         } // if
                 } // if
-                tyVars.endScope();
                 return ret;
+        }
         Type * FindFunction::mutate( PointerType *pointerType ) {
                 tyVars.beginScope();
+        void FindFunction::premutate( PointerType * pointerType ) {
+                GuardScope( tyVars );
                 handleForall( pointerType->get_forall() );
-                Type *ret = Mutator::mutate( pointerType );
-                tyVars.endScope();
-                return ret;
+        }
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

-              r78315272
+              r3f7e12cb
+        }
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env ) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                Type * newType = arg->clone();
+                if ( env ) env->apply( newType );
+                std::unique_ptr<Type> manager( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env ) {
+                FunctionType * function = getFunctionType( appExpr->function->result );
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
+                TyVarMap exprTyVars( TypeDecl::Data{} );
+                makeTyVarMap( function, exprTyVars );
+                return needsBoxing( param, arg, exprTyVars, env );
+        }
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 // xxx - should this actually be insert?

src/GenPoly/GenPoly.h

-              r78315272
+              r3f7e12cb
         bool typesPolyCompatible( Type *aty, Type *bty );
+        /// true if arg requires boxing given exprTyVars
+        bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, TypeSubstitution * env );
+        /// true if arg requires boxing in the call to appExpr
+        bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, TypeSubstitution * env );
         /// Adds the type variable `tyVar` to `tyVarMap`
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap );

src/GenPoly/InstantiateGeneric.cc

-              r78315272
+              r3f7e12cb
                                         assertf( false, "Ttype parameters are not currently allowed as parameters to generic types." );
                                         break;
                                 case TypeDecl::Any:
                                         assertf( false, "otype parameters handled by baseParam->isComplete()." );
+                                default:
+                                        assertf( false, "Unhandled type parameter kind" );
                                         break;
+                        }
 …
                 substituteMembers( base->get_members(), baseParams, typeSubs );
+                deleteAll( baseParams );
+                // xxx - can't delete type parameters because they may have assertions that are used
+                // deleteAll( baseParams );
                 baseParams.clear();

src/GenPoly/ScrubTyVars.cc

r78315272	r3f7e12cb
40	40	if ( tyVar != tyVars->end() ) {
41	41	switch ( tyVar->second.kind ) {
42		~~case TypeDecl::Any:~~
43	42	case TypeDecl::Dtype:
44	43	case TypeDecl::Ttype:

src/GenPoly/Specialize.cc

-              r78315272
+              r3f7e12cb
 #include <utility>                       // for pair
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
 …
 #include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
 #include "Parser/LinkageSpec.h"          // for C
-#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
 …
 namespace GenPoly {
+        class Specialize final : public PolyMutator {
+          public:
+                using PolyMutator::mutate;
+                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
+                virtual Expression * mutate( AddressExpr *castExpr ) override;
+                virtual Expression * mutate( CastExpr *castExpr ) override;
+                // virtual Expression * mutate( LogicalExpr *logicalExpr );
+                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
+                // virtual Expression * mutate( CommaExpr *commaExpr );
+        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+                Expression * postmutate( ApplicationExpr *applicationExpr );
+                Expression * postmutate( CastExpr *castExpr );
                 void handleExplicitParams( ApplicationExpr *appExpr );
                 Expression * createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams );
                 Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams = nullptr );
+                Expression * doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams );
                 std::string paramPrefix = "_p";
 …
                                 if ( ! boundType ) continue;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) {
+                                        // bound to another type variable
                                         if ( closedVars.find( typeInst->get_name() ) == closedVars.end() ) {
+                                                // bound to a closed variable => must specialize
                                                 return true;
                                         } // if
                                 } else {
+                                        // variable is bound to a concrete type => must specialize
                                         return true;
                                 } // if
                         } // for
+                        // none of the type variables are bound
                         return false;
                 } else {
+                        // no env
                         return false;
                 } // if
 …
                         if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;
                         // tuple-parameter sizes are the same, but actual parameter sizes differ - must tuple specialize
                         if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true;
+                        if ( fftype->parameters.size() != aftype->parameters.size() ) return true;
                         // total parameter size can be the same, while individual parameters can have different structure
                         for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) {
+                        for ( auto params : group_iterate( fftype->parameters, aftype->parameters ) ) {
                                 DeclarationWithType * formal = std::get<0>(params);
                                 DeclarationWithType * actual = std::get<1>(params);
 …
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
                 assertf( actual->has_result(), "attempting to specialize an untyped expression" );
+                assertf( actual->result, "attempting to specialize an untyped expression" );
                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
                         if ( FunctionType *funType = getFunctionType( formalType ) ) {
+                                ApplicationExpr *appExpr;
+                                VariableExpr *varExpr;
+                                if ( ( appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) ) {
+                                if ( ApplicationExpr * appExpr = dynamic_cast<ApplicationExpr*>( actual ) ) {
                                         return createThunkFunction( funType, appExpr->get_function(), inferParams );
                                 } else if ( ( varExpr = dynamic_cast<VariableExpr*>( actual ) ) ) {
+                                } else if ( VariableExpr * varExpr = dynamic_cast<VariableExpr*>( actual ) ) {
                                         return createThunkFunction( funType, varExpr, inferParams );
                                 } else {
 …
+        }
         struct EnvTrimmer : public Visitor {
+        struct EnvTrimmer {
                 TypeSubstitution * env, * newEnv;
                 EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
                 virtual void visit( TypeDecl * tyDecl ) {
+                void previsit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
                         if ( Type * t = env->lookup( tyDecl->get_name() ) ) {
                                 newEnv->add( tyDecl->get_name(), t );
+                        if ( Type * t = env->lookup( tyDecl->name ) ) {
+                                newEnv->add( tyDecl->name, t );
+                        }
+                }
 …
                 if ( env ) {
                         TypeSubstitution * newEnv = new TypeSubstitution();
                         EnvTrimmer trimmer( env, newEnv );
+                        PassVisitor<EnvTrimmer> trimmer( env, newEnv );
                         expr->accept( trimmer );
                         return newEnv;
 …
                 std::string oldParamPrefix = paramPrefix;
                 paramPrefix += "p";
                 // save stmtsToAdd in oldStmts
+                // save stmtsToAddBefore in oldStmts
                 std::list< Statement* > oldStmts;
                 oldStmts.splice( oldStmts.end(), stmtsToAdd );
                 mutate( appExpr );
+                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
+                appExpr->acceptMutator( *visitor );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
                 thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
                 // restore oldStmts into stmtsToAdd
                 stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
+                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
+                // restore oldStmts into stmtsToAddBefore
+                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
                 // add return (or valueless expression) to the thunk
                 Statement *appStmt;
                 if ( funType->get_returnVals().empty() ) {
+                if ( funType->returnVals.empty() ) {
                         appStmt = new ExprStmt( noLabels, appExpr );
                 } else {
                         appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
                 thunkFunc->get_statements()->get_kids().push_back( appStmt );
+                thunkFunc->statements->kids.push_back( appStmt );
                 // add thunk definition to queue of statements to add
                 stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );
 …
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
                 assert( appExpr->get_function()->has_result() );
                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( appExpr->function->result );
+                FunctionType *function = getFunctionType( appExpr->function->result );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
+                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+        Expression * Specialize::mutate( ApplicationExpr *appExpr ) {
+                appExpr->get_function()->acceptMutator( *this );
+                mutateAll( appExpr->get_args(), *this );
+                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+        Expression * Specialize::postmutate( ApplicationExpr *appExpr ) {
                 if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) {
                         // create thunks for the inferred parameters
 …
+        }
+        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
+                addrExpr->get_arg()->acceptMutator( *this );
+                assert( addrExpr->has_result() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                return addrExpr;
+        }
+        Expression * Specialize::mutate( CastExpr *castExpr ) {
+                castExpr->get_arg()->acceptMutator( *this );
+                if ( castExpr->get_result()->isVoid() ) {
+        Expression * Specialize::postmutate( CastExpr *castExpr ) {
+                if ( castExpr->result->isVoid() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
+                }
                 Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
+                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg, &castExpr->inferParams );
+                if ( specialized != castExpr->arg ) {
                         // assume here that the specialization incorporates the cast
                         return specialized;
 …
+        }
-        // Removing these for now. Richard put these in for some reason, but it's not clear why.
-        // In particular, copy constructors produce a comma expression, and with this code the parts
-        // of that comma expression are not specialized, which causes problems.
-        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
-        //      return logicalExpr;
-        // }
-        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
-        //      return condExpr;
-        // }
-        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
-        //      return commaExpr;
-        // }
         void convertSpecializations( std::list< Declaration* >& translationUnit ) {
                 Specialize spec;
+                PassVisitor<Specialize> spec;
                 mutateAll( translationUnit, spec );
+        }

src/GenPoly/module.mk

-              r78315272
+              r3f7e12cb
 ## file "LICENCE" distributed with Cforall.
 ##
 ## module.mk --
+## module.mk --
 ##
 ## Author           : Richard C. Bilson
 …
 SRC += GenPoly/Box.cc \
        GenPoly/GenPoly.cc \
-       GenPoly/PolyMutator.cc \
        GenPoly/ScrubTyVars.cc \
        GenPoly/Lvalue.cc \
        GenPoly/Specialize.cc \
-       GenPoly/CopyParams.cc \
        GenPoly/FindFunction.cc \
-       GenPoly/DeclMutator.cc \
        GenPoly/InstantiateGeneric.cc

src/InitTweak/FixInit.cc

-              r78315272
+              r3f7e12cb
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
-#include "GenPoly/DeclMutator.h"       // for DeclMutator
 #include "GenPoly/GenPoly.h"           // for getFunctionType
-#include "GenPoly/PolyMutator.h"       // for PolyMutator
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
 #include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
 …
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
-#include "SynTree/AddStmtVisitor.h"    // for AddStmtVisitor
 #include "SynTree/Attribute.h"         // for Attribute
 #include "SynTree/Constant.h"          // for Constant
 …
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
-#include "Tuples/Tuples.h"             // for isTtype
 bool ctordtorp = false; // print all debug
 …
                         /// true if type does not need to be copy constructed to ensure correctness
                         bool skipCopyConstruct( Type * type );
                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal );
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 …
                 };
                 class FixCopyCtors final : public GenPoly::PolyMutator {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
 …
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
+                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void premutate( StmtExpr * stmtExpr );
+                        void premutate( UniqueExpr * unqExpr );
                         UnqCount & unqCount;
 …
                         void emit( CodeLocation, const Params &... params );
                         FunctionDecl * function = 0;
+                        FunctionDecl * function = nullptr;
                         std::set< DeclarationWithType * > unhandled;
                         std::map< DeclarationWithType *, CodeLocation > usedUninit;
                         ObjectDecl * thisParam = 0;
+                        ObjectDecl * thisParam = nullptr;
                         bool isCtor = false; // true if current function is a constructor
                         StructDecl * structDecl = 0;
+                        StructDecl * structDecl = nullptr;
                 };
 …
                 };
+                class FixCtorExprs final : public GenPoly::DeclMutator {
+                  public:
+                struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer {
                         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
                         static void fix( std::list< Declaration * > & translationUnit );
+                        using GenPoly::DeclMutator::mutate;
+                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
+                        Expression * postmutate( ConstructorExpr * ctorExpr );
                 };
         } // namespace
 …
                 GenStructMemberCalls::generate( translationUnit );
                 // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a
                 // hack in the way untyped assignments are generated, where the first argument cannot have
 …
                         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                                 try {
                                         *i = maybeMutate( *i, fixer );
+                                        maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
 …
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
                         FixCopyCtors fixer( unqCount );
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         mutateAll( translationUnit, fixer );
+                }
 …
                 void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
                         FixCtorExprs fixer;
                         fixer.mutateDeclarationList( translationUnit );
+                        PassVisitor<FixCtorExprs> fixer;
+                        mutateAll( translationUnit, fixer );
+                }
                 Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
-                        assert( appExpr );
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
                                 if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
+                                if ( function->var->linkage.is_builtin ) {
                                         // optimization: don't need to copy construct in order to call intrinsic functions
                                         return appExpr;
                                 } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
                                         if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
+                                        assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->parameters.size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->parameters.front()->get_type() );
+                                                Type * t2 = ftype->parameters.back()->get_type();
                                                 assert( t1 );
 …
+                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
 …
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
                         ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
+                        Expression * untyped = exprStmt->get_expr();
+                        Expression * resolved = exprStmt->expr;
+                        exprStmt->expr = nullptr; // take ownership of expr
                         // resolve copy constructor
                         // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
                         Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
+                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; )
+                        ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
 …
                                 resolved->set_env( nullptr );
                         } // if
                         delete stmt;
                         return resolved;
+                }
                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal ) {
                         static UniqueName tempNamer("_tmp_cp");
                         assert( env );
                         CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
                         assert( arg->has_result() );
                         Type * result = arg->get_result();
+                        assert( arg->result );
+                        Type * result = arg->result;
                         if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type.
+                        // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
                         result = result->clone();
                         env->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                        env->applyFree( result );
+                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
 …
                                 // if the chosen constructor is intrinsic, the copy is unnecessary, so
                                 // don't create the temporary and don't call the copy constructor
+                                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
+                                assert( function );
+                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
+                        }
+                                VariableExpr * function = strict_dynamic_cast< VariableExpr * >( appExpr->function );
+                                if ( function->var->linkage == LinkageSpec::Intrinsic ) {
+                                        // arguments that need to be boxed need a temporary regardless of whether the copy constructor is intrinsic,
+                                        // so that the object isn't changed inside of the polymorphic function
+                                        if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
+                                }
+                        }
+                        // set a unique name for the temporary once it's certain the call is necessary
+                        tmp->name = tempNamer.newName();
                         // replace argument to function call with temporary
                         arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
                         impCpCtorExpr->get_tempDecls().push_back( tmp );
                         impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
+                        impCpCtorExpr->tempDecls.push_back( tmp );
+                        impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
+                }
 …
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+                        ApplicationExpr * appExpr = impCpCtorExpr->callExpr;
                         // take each argument and attempt to copy construct it.
+                        for ( Expression * & arg : appExpr->get_args() ) {
+                                copyConstructArg( arg, impCpCtorExpr );
+                        FunctionType * ftype = GenPoly::getFunctionType( appExpr->function->result );
+                        assert( ftype );
+                        auto & params = ftype->parameters;
+                        auto iter = params.begin();
+                        for ( Expression * & arg : appExpr->args ) {
+                                Type * formal = nullptr;
+                                if ( iter != params.end() ) {
+                                        DeclarationWithType * param = *iter++;
+                                        formal = param->get_type();
+                                }
+                                copyConstructArg( arg, impCpCtorExpr, formal );
                         } // for
 …
                         // initialized with the return value and is destructed later
                         // xxx - handle named return values?
                         Type * result = appExpr->get_result();
+                        Type * result = appExpr->result;
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
                                 result = result->clone();
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
+                                ret->type->set_const( false );
+                                impCpCtorExpr->returnDecls.push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
+                                }
 …
                                 result = result->clone();
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
 …
                                 visit_children = false;
+                        }
+                }
+                // to prevent warnings (‘_unq0’ may be used uninitialized in this function),
+                // insert an appropriate zero initializer for UniqueExpr temporaries.
+                Initializer * makeInit( Type * t ) {
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) {
+                                // initizer for empty struct must be empty
+                                if ( inst->baseStruct->members.empty() ) return new ListInit({});
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
+                                // initizer for empty union must be empty
+                                if ( inst->baseUnion->members.empty() ) return new ListInit({});
+                        }
+                        return new ListInit( { new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) } );
+                }
 …
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
                                 unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), makeInit( unqExpr->get_result() ) ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
+                        }
 …
+                }
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
-                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
 …
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
                                 stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
                                 stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 …
                         } // for
-                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
 …
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 // move env from callExpr to retExpr
+                                retExpr->set_env( callExpr->get_env() );
+                                callExpr->set_env( nullptr );
+                                std::swap( retExpr->env, callExpr->env );
                                 return retExpr;
                         } else {
 …
+                }
                 Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
+                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
                         //   [A, A] f();
                         //   g([A] x, [A] y);
                         //   f(g());
+                        //   g(f());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
+                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
+                        // to the outer context, rather than inside of the statement expression.
+                        visit_children = false;
                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
                                 stmt = stmt->acceptMutator( *this );
+                                stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
                                         stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
 …
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
+                                assert( ! stmts.empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
                                 body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
 …
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
                         return stmtExpr;
+                }
                 Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
+                }
+                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
+                        visit_children = false;
                         unqCount[ unqExpr->get_id() ]--;
                         static std::unordered_map< int, std::list< Statement * > > dtors;
                         static std::unordered_map< int, UniqueExpr * > unqMap;
-                        static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
                         if ( unqMap.count( unqExpr->get_id() ) ) {
 …
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
+                                }
+                                if ( addDeref.count( unqExpr->get_id() ) ) {
+                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
+                                        return UntypedExpr::createDeref( unqExpr );
+                                }
+                                return unqExpr;
+                        }
+                        FixCopyCtors fixer( unqCount );
+                                return;
+                        }
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
                         stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
+                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
                                 stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                         } else { // remember dtors for last instance of unique expr
+                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                        }
+                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
+                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
+                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
+                                // (i.e. move the dereference out a level)
+                                assert( getFunctionName( deref ) == "*?" );
+                                unqExpr->set_expr( getCallArg( deref, 0 ) );
+                                getCallArg( deref, 0 ) = unqExpr;
+                                addDeref.insert( unqExpr->get_id() );
+                                return deref;
+                        }
+                        return unqExpr;
+                }
+                DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) {
+                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
+                        }
+                        return;
+                }
+                DeclarationWithType * FixInit::postmutate( ObjectDecl *objDecl ) {
                         // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate)
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
 …
                                         } else {
                                                 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
                                                 ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt );
                                                 ApplicationExpr * ctorCall = nullptr;
                                                 if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) {
+                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
+                                                        objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) );
+                                                        ctorCall->get_args().pop_back();
+                                                        Expression * ctorArg = ctorCall->args.back();
+                                                        std::swap( ctorArg->env, ctorCall->env );
+                                                        objDecl->init = new SingleInit( ctorArg );
+                                                        ctorCall->args.pop_back();
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
                                                         objDecl->set_init( nullptr );
                                                         ctorInit->set_ctor( nullptr );
+                                                        objDecl->init = nullptr;
+                                                        ctorInit->ctor = nullptr;
+                                                }
                                         } // if
                                 } else if ( Initializer * init = ctorInit->get_init() ) {
                                         objDecl->set_init( init );
                                         ctorInit->set_init( nullptr );
+                                } else if ( Initializer * init = ctorInit->init ) {
+                                        objDecl->init = init;
+                                        ctorInit->init = nullptr;
                                 } else {
                                         // no constructor and no initializer, which is okay
                                         objDecl->set_init( nullptr );
+                                        objDecl->init = nullptr;
                                 } // if
                                 delete ctorInit;
 …
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
+                                        // don't need to call intrinsic dtor, because it does nothing, but
+                                        // non-intrinsic dtors must be called
                                         if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                                 // don't need to call intrinsic dtor, because it does nothing, but
                                                 // non-intrinsic dtors must be called
+                                                // set dtor location to the object's location for error messages
+                                                ctorInit->dtor->location = objDecl->location;
                                                 reverseDeclOrder.front().push_front( objDecl );
                                         } // if
 …
                         GuardValue( labelVars );
                         labelVars.clear();
+                        // LabelFinder does not recurse into FunctionDecl, so need to visit
+                        // its children manually.
                         maybeAccept( funcDecl->type, finder );
                         maybeAccept( funcDecl->statements, finder );
 …
+                }
+                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
+                        for ( auto d : decls ) {
+                                indexer.addId( d );
+                        }
+                }
+                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
+                        for ( auto td : tds ) {
+                                indexer.addType( td );
+                                addIds( indexer, td->assertions );
+                        }
+                }
                 void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
                         GuardValue( funcDecl );
+                        GuardValue( function );
                         GuardValue( unhandled );
                         GuardValue( usedUninit );
 …
+                }
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
+                        }
+                }
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
+                        }
+                }
                 void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
 …
                                         // skip non-DWT members
                                         if ( ! field ) continue;
+                                        // skip non-constructable members
+                                        if ( ! tryConstruct( field ) ) continue;
                                         // skip handled members
                                         if ( ! unhandled.count( field ) ) continue;
 …
+                }
                 DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
+                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
                         // add object to the indexer assumes that there will be no name collisions
                         // in generated code. If this changes, add mutate methods for entities with
 …
+                }
+                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
+                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+                }
+                Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
+                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                        Expression * newExpr = untypedExpr;
+                        ResolvExpr::findVoidExpression( newExpr, indexer );
+                        return newExpr;
+                }
+                Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
                         assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
+                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
                         addDeclaration( tmp );
+                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
+                        declsToAddBefore.push_back( tmp );
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
 …
                         delete ctorExpr;
+                        // build assignment and replace constructor's first argument with new temporary
                         Expression *& firstArg = callExpr->get_args().front();
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } );
                         firstArg = new VariableExpr( tmp );
+                        // resolve assignment and dispose of new env
+                        ResolvExpr::findVoidExpression( assign, indexer );
+                        delete assign->env;
+                        assign->env = nullptr;
                         // for constructor expr:

src/InitTweak/GenInit.cc

-              r78315272
+              r3f7e12cb
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for ValueGuard, maybeClone
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
 …
         };
         struct CtorDtor : public WithGuards, public WithShortCircuiting  {
+        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
 …
                 // that need to be constructed or destructed
                 void previsit( StructDecl *aggregateDecl );
+                void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
+                void previsit( AggregateDecl * ) { visit_children = false; }
+                void previsit( NamedTypeDecl * ) { visit_children = false; }
+                void previsit( FunctionType * ) { visit_children = false; }
                 void previsit( CompoundStmt * compoundStmt );
 …
                 // should not have a ConstructorInit generated.
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( Type * type ) const; // determine if type is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                GenPoly::ScopedSet< std::string > managedTypes;
+                ManagedTypes managedTypes;
                 bool inFunction = false;
         };
+        class HoistArrayDimension final : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
                 /// hoist dimension from array types in object declaration so that it uses a single
                 /// const variable of type size_t, so that side effecting array dimensions are only
 …
                 static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
+          private:
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void premutate( ObjectDecl * objectDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
+                void premutate( FunctionDecl *functionDecl );
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
+                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
+                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
+                void premutate( AggregateDecl * ) { visit_children = false; }
+                void premutate( NamedTypeDecl * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
                 void hoist( Type * type );
 …
         void genInit( std::list< Declaration * > & translationUnit ) {
                 ReturnFixer::makeReturnTemp( translationUnit );
+                fixReturnStatements( translationUnit );
                 HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
+        }
         void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
+        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
 …
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
+                        assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
+                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
+                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
+                                // return statement has already been mutated - don't need to do it again
+                                if ( varExpr->var == retVal ) return;
+                        }
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
                         // return the retVal object
                         returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
+                        returnStmt->expr = new VariableExpr( returnVals.front() );
                 } // if
+        }
 …
                 GuardValue( funcName );
                 ftype = functionDecl->get_functionType();
                 funcName = functionDecl->get_name();
+                ftype = functionDecl->type;
+                funcName = functionDecl->name;
+        }
 …
         // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
+                HoistArrayDimension hoister;
+                hoister.mutateDeclarationList( translationUnit );
+        }
+        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
+                PassVisitor<HoistArrayDimension> hoister;
+                mutateAll( translationUnit, hoister );
+        }
+        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
+                GuardValue( storageClasses );
                 storageClasses = objectDecl->get_storageClasses();
+                DeclarationWithType * temp = Parent::mutate( objectDecl );
+        }
+        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
                 hoist( objectDecl->get_type() );
                 return temp;
+                return objectDecl;
+        }
 …
                         arrayType->set_dimension( new VariableExpr( arrayDimension ) );
                         addDeclaration( arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
                         hoist( arrayType->get_base() );
 …
+        }
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc( inFunction );
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                return decl;
+        void HoistArrayDimension::premutate( FunctionDecl * ) {
+                GuardValue( inFunction );
+        }
 …
+        }
         bool CtorDtor::isManaged( Type * type ) const {
                 // at least for now, references are never constructed
+        bool ManagedTypes::isManaged( Type * type ) const {
+                // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
 …
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
                         // tuple is also managed if any of its components are managed
                         if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
+                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
                                 return true;
+                        }
+                }
                 // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
                 return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
+        }
         bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+                return managedTypes.find( SymTab::Mangler::mangleConcrete( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
+        }
+        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
 …
+        }
         void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+        void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
 …
                         Type * type = InitTweak::getPointerBase( params.front()->get_type() );
                         assert( type );
+                        managedTypes.insert( SymTab::Mangler::mangle( type ) );
+                }
+        }
+                        managedTypes.insert( SymTab::Mangler::mangleConcrete( type ) );
+                }
+        }
+        void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        // generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that
+                                        // polymorphic constructors make generic types managed types
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangleConcrete( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
+        void ManagedTypes::endScope() { managedTypes.endScope(); }
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
 …
         void CtorDtor::previsit( ObjectDecl * objDecl ) {
                 handleDWT( objDecl );
+                managedTypes.handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
                 if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
+                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
 …
         void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;  // do not try and construct parameters or forall parameters
                 GuardValue( inFunction );
                 inFunction = true;
                 handleDWT( functionDecl );
+                managedTypes.handleDWT( functionDecl );
                 GuardScope( managedTypes );
 …
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 handleDWT( assertion );
+                                managedTypes.handleDWT( assertion );
+                        }
+                }
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+                maybeAccept( functionDecl->get_statements(), *visitor );
+        }
 …
                 visit_children = false; // do not try to construct and destruct aggregate members
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+        void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
+                managedTypes.handleStruct( aggregateDecl );
+        }
+        void CtorDtor::previsit( CompoundStmt * ) {
                 GuardScope( managedTypes );
+        }

src/InitTweak/GenInit.h

-              r78315272
+              r3f7e12cb
 #pragma once
 #include <list>               // for list
 #include <string>             // for string
+#include <list>                // for list
+#include <string>              // for string
+#include "SynTree/SynTree.h"  // for Visitor Nodes
+#include "SynTree/SynTree.h"   // for Visitor Nodes
+#include "GenPoly/ScopedSet.h" // for ScopedSet
 namespace InitTweak {
 …
         void genInit( std::list< Declaration * > & translationUnit );
+  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        /// Converts return statements into copy constructor calls on the hidden return variable
+        void fixReturnStatements( std::list< Declaration * > & translationUnit );
+        /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
         ConstructorInit * genCtorInit( ObjectDecl * objDecl );
+        class ManagedTypes {
+        public:
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( Type * type ) const; // determine if type is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                void handleStruct( StructDecl * aggregateDecl ); // add type to managed if child is managed
+                void beginScope();
+                void endScope();
+        private:
+                GenPoly::ScopedSet< std::string > managedTypes;
+        };
 } // namespace

src/InitTweak/InitTweak.cc

-              r78315272
+              r3f7e12cb
-#include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
 …
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
 #include "SynTree/Visitor.h"       // for Visitor, maybeAccept
+#include "Tuples/Tuples.h"         // for Tuples::isTtype
 class UntypedValofExpr;
 …
+        }
+        bool InitExpander::addReference() {
+                bool added = false;
+                for ( Expression *& expr : cur ) {
+                        expr = new AddressExpr( expr );
+                        added = true;
+                }
+                return added;
+        }
         namespace {
                 /// given index i, dimension d, initializer init, and callExpr f, generates
 …
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
                         *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
 …
         // To accomplish this, generate switch statement, consuming all of expander's elements
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return NULL;
+                if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
                         delete block;
                         return NULL;
+                        return nullptr;
                 } else {
                         init = NULL; // init was consumed in creating the list init
+                        init = nullptr; // init was consumed in creating the list init
                         return block;
+                }
+        }
         Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
                 return NULL;
+        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+                return nullptr;
+        }
 …
+        }
+        bool tryConstruct( ObjectDecl * objDecl ) {
+        Type * getTypeofThis( FunctionType * ftype ) {
+                assertf( ftype, "getTypeofThis: nullptr ftype" );
+                ObjectDecl * thisParam = getParamThis( ftype );
+                ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type );
+                return refType->base;
+        }
+        ObjectDecl * getParamThis( FunctionType * ftype ) {
+                assertf( ftype, "getParamThis: nullptr ftype" );
+                auto & params = ftype->parameters;
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( ftype ).c_str() );
+                return strict_dynamic_cast< ObjectDecl * >( params.front() );
+        }
+        bool tryConstruct( DeclarationWithType * dwt ) {
+                ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
+                        (objDecl->get_init() == NULL ||
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern;
+                        (objDecl->get_init() == nullptr ||
+                                ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern
+                        && isConstructable( objDecl->type );
+        }
+        bool isConstructable( Type * type ) {
+                return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
 …
                 collectCtorDtorCalls( stmt, matches );
                 assert( matches.size() <= 1 );
                 return matches.size() == 1 ? matches.front() : NULL;
+                return matches.size() == 1 ? matches.front() : nullptr;
+        }
 …
                         assert( expr );
                         if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
                                 return varExpr->get_var();
+                                return varExpr->var;
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
                                 return memberExpr->get_member();
+                                return memberExpr->member;
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 return getCalledFunction( castExpr->get_arg() );
+                                return getCalledFunction( castExpr->arg );
                         } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
                                 return handleDerefCalledFunction( untypedExpr );
 …
                                 return handleDerefCalledFunction( appExpr );
                         } else if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                                return getCalledFunction( addrExpr->get_arg() );
+                                return getCalledFunction( addrExpr->arg );
+                        } else if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( expr ) ) {
+                                return getCalledFunction( commaExpr->arg2 );
+                        }
                         return nullptr;
 …
         ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
                 ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
                 if ( ! appExpr ) return NULL;
+                if ( ! appExpr ) return nullptr;
                 DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
                 assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
                 // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
                 // will call all member dtors, and some members may have a user defined dtor.
                 return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
+                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
+        }
 …
                         return refType->get_base();
                 } else {
                         return NULL;
+                        return nullptr;
+                }
+        }
 …
         Type * isPointerType( Type * type ) {
                 if ( getPointerBase( type ) ) return type;
                 else return NULL;
+                else return nullptr;
+        }
 …
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
                 FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
                 if ( ! function ) return 0;
                 if ( function->get_name() != fname ) return 0;
                 FunctionType * ftype = function->get_functionType();
                 if ( ftype->get_parameters().size() != 2 ) return 0;
+                if ( ! function ) return nullptr;
+                if ( function->name != fname ) return nullptr;
+                FunctionType * ftype = function->type;
+                if ( ftype->parameters.size() != 2 ) return nullptr;
                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                 Type * t2 = ftype->get_parameters().back()->get_type();
+                Type * t2 = ftype->parameters.back()->get_type();
                 assert( t1 );
 …
+        }
         FunctionDecl * isDefaultConstructor( Declaration * decl ) {
                 if ( isConstructor( decl->get_name() ) ) {
+                if ( isConstructor( decl->name ) ) {
                         if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
                                 if ( func->get_functionType()->get_parameters().size() == 1 ) {
+                                if ( func->type->parameters.size() == 1 ) {
                                         return func;
+                                }

src/InitTweak/InitTweak.h

-              r78315272
+              r3f7e12cb
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
+        /// returns the base type of the first parameter to a constructor/destructor/assignment function
+        Type * getTypeofThis( FunctionType * ftype );
+        /// returns the first parameter of a constructor/destructor/assignment function
+        ObjectDecl * getParamThis( FunctionType * ftype );
         /// transform Initializer into an argument list that can be passed to a call expression
         std::list< Expression * > makeInitList( Initializer * init );
+        /// True if the resolver should try to construct objDecl
+        bool tryConstruct( ObjectDecl * objDecl );
+        /// True if the resolver should try to construct dwt
+        bool tryConstruct( DeclarationWithType * dwt );
+        /// True if the type can have a user-defined constructor
+        bool isConstructable( Type * t );
         /// True if the Initializer contains designations
 …
                 void addArrayIndex( Expression * index, Expression * dimension );
                 void clearArrayIndices();
+                bool addReference();
                 class ExpanderImpl;

src/MakeLibCfa.cc

-              r78315272
+              r3f7e12cb
                         newDecls.push_back( funcDecl );
+                        Statement * stmt = nullptr;
                         switch ( opInfo.type ) {
                           case CodeGen::OT_INDEX:
 …
                           case CodeGen::OT_POSTFIXASSIGN:
                           case CodeGen::OT_INFIXASSIGN:
+                                        // return the recursive call
+                                        stmt = new ReturnStmt( noLabels, newExpr );
+                                        break;
                           case CodeGen::OT_CTOR:
                           case CodeGen::OT_DTOR:
                                 // return the recursive call
                                         funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+                                        // execute the recursive call
+                                        stmt = new ExprStmt( noLabels, newExpr );
                                         break;
                           case CodeGen::OT_CONSTANT:
 …
                                 assert( false );
                         } // switch
+                        funcDecl->get_statements()->push_back( stmt );
+                }
         } // namespace

src/Makefile.in

-              r78315272
+              r3f7e12cb
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
-        GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
         InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \
 …
         SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
 …
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
+        GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
+        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
+        GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
+        GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \
+        InitTweak/GenInit.cc InitTweak/FixInit.cc \
+        InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
+        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
+        Parser/ParseNode.cc Parser/DeclarationNode.cc \
+        Parser/ExpressionNode.cc Parser/StatementNode.cc \
+        Parser/InitializerNode.cc Parser/TypeData.cc \
+        Parser/LinkageSpec.cc Parser/parserutility.cc \
+        ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
+        ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
+        ResolvExpr/CommonType.cc ResolvExpr/ConversionCost.cc \
+        ResolvExpr/CastCost.cc ResolvExpr/PtrsCastable.cc \
+        ResolvExpr/AdjustExprType.cc ResolvExpr/AlternativePrinter.cc \
+        ResolvExpr/Resolver.cc ResolvExpr/ResolveTypeof.cc \
+        ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
+        ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
+        ResolvExpr/TypeEnvironment.cc ResolvExpr/CurrentObject.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SynTree/VoidType.cc SynTree/BasicType.cc \
+        SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
+        GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
+        GenPoly/Specialize.cc GenPoly/FindFunction.cc \
+        GenPoly/InstantiateGeneric.cc InitTweak/GenInit.cc \
+        InitTweak/FixInit.cc InitTweak/FixGlobalInit.cc \
+        InitTweak/InitTweak.cc Parser/parser.yy Parser/lex.ll \
+        Parser/TypedefTable.cc Parser/ParseNode.cc \
+        Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
+        Parser/StatementNode.cc Parser/InitializerNode.cc \
+        Parser/TypeData.cc Parser/LinkageSpec.cc \
+        Parser/parserutility.cc ResolvExpr/AlternativeFinder.cc \
+        ResolvExpr/Alternative.cc ResolvExpr/Unify.cc \
+        ResolvExpr/PtrsAssignable.cc ResolvExpr/CommonType.cc \
+        ResolvExpr/ConversionCost.cc ResolvExpr/CastCost.cc \
+        ResolvExpr/PtrsCastable.cc ResolvExpr/AdjustExprType.cc \
+        ResolvExpr/AlternativePrinter.cc ResolvExpr/Resolver.cc \
+        ResolvExpr/ResolveTypeof.cc ResolvExpr/RenameVars.cc \
+        ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \
+        ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
+        ResolvExpr/CurrentObject.cc SymTab/Indexer.cc \
+        SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
+        SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
+        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
+        SynTree/BasicType.cc SynTree/PointerType.cc \
+        SynTree/ArrayType.cc SynTree/ReferenceType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
 …
         SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
         SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
         SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
         Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
         Tuples/Explode.cc Virtual/ExpandCasts.cc
+        SynTree/TypeSubstitution.cc SynTree/Attribute.cc \
+        SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc Tuples/Explode.cc \
+        Virtual/ExpandCasts.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
 …
 GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 …
 GenPoly/driver_cfa_cpp-Specialize.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
-GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
-        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
 …
 SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT):  \
-        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AggregateDecl.Po@am__quote@
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-GenPoly.obj `if test -f 'GenPoly/GenPoly.cc'; then $(CYGPATH_W) 'GenPoly/GenPoly.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/GenPoly.cc'; fi`
-GenPoly/driver_cfa_cpp-PolyMutator.o: GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
-GenPoly/driver_cfa_cpp-PolyMutator.obj: GenPoly/PolyMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
 GenPoly/driver_cfa_cpp-ScrubTyVars.o: GenPoly/ScrubTyVars.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-ScrubTyVars.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Tpo -c -o GenPoly/driver_cfa_cpp-ScrubTyVars.o `test -f 'GenPoly/ScrubTyVars.cc' || echo '$(srcdir)/'`GenPoly/ScrubTyVars.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-Specialize.obj `if test -f 'GenPoly/Specialize.cc'; then $(CYGPATH_W) 'GenPoly/Specialize.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/Specialize.cc'; fi`
-GenPoly/driver_cfa_cpp-CopyParams.o: GenPoly/CopyParams.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-CopyParams.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo -c -o GenPoly/driver_cfa_cpp-CopyParams.o `test -f 'GenPoly/CopyParams.cc' || echo '$(srcdir)/'`GenPoly/CopyParams.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/CopyParams.cc' object='GenPoly/driver_cfa_cpp-CopyParams.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-CopyParams.o `test -f 'GenPoly/CopyParams.cc' || echo '$(srcdir)/'`GenPoly/CopyParams.cc
-GenPoly/driver_cfa_cpp-CopyParams.obj: GenPoly/CopyParams.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-CopyParams.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo -c -o GenPoly/driver_cfa_cpp-CopyParams.obj `if test -f 'GenPoly/CopyParams.cc'; then $(CYGPATH_W) 'GenPoly/CopyParams.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/CopyParams.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/CopyParams.cc' object='GenPoly/driver_cfa_cpp-CopyParams.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-CopyParams.obj `if test -f 'GenPoly/CopyParams.cc'; then $(CYGPATH_W) 'GenPoly/CopyParams.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/CopyParams.cc'; fi`
 GenPoly/driver_cfa_cpp-FindFunction.o: GenPoly/FindFunction.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-FindFunction.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Tpo -c -o GenPoly/driver_cfa_cpp-FindFunction.o `test -f 'GenPoly/FindFunction.cc' || echo '$(srcdir)/'`GenPoly/FindFunction.cc
 …
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi`
-GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
-GenPoly/driver_cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
 GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi`
-SynTree/driver_cfa_cpp-AddStmtVisitor.o: SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
-SynTree/driver_cfa_cpp-AddStmtVisitor.obj: SynTree/AddStmtVisitor.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
 SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc

src/Parser/DeclarationNode.cc

-              r78315272
+              r3f7e12cb
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug 10 17:02:00 2017
 // Update Count     : 1021
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Sep 23 18:16:48 2017
+// Update Count     : 1024
 //
 …
 using namespace std;
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
 const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
+// These must harmonize with the corresponding DeclarationNode enumerations.
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "int128", "float80", "float128", "NoBasicTypeNames" };
 const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
 const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
 …
         if ( variable.tyClass != NoTypeClass ) {
+                static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
+                assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
+                // otype is internally converted to dtype + otype parameters
+                static const TypeDecl::Kind kindMap[] = { TypeDecl::Dtype, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
+                assertf( sizeof(kindMap)/sizeof(kindMap[0]) == NoTypeClass, "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
                 TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.initializer ? variable.initializer->buildType() : nullptr );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ], variable.tyClass == Otype, variable.initializer ? variable.initializer->buildType() : nullptr );
                 buildList( variable.assertions, ret->get_assertions() );
                 return ret;

src/Parser/ExpressionNode.cc

-              r78315272
+              r3f7e12cb
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 14 23:09:34 2017
 // Update Count     : 690
+// Last Modified On : Wed Sep 27 22:51:55 2017
+// Update Count     : 781
 //
 …
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
+static const char * lnthsInt[2][6] = {
+        { "int8_t", "int16_t", "int32_t", "int64_t", "size_t", },
+        { "uint8_t", "uint16_t", "uint32_t", "uint64_t", "size_t", }
+}; // lnthsInt
+static inline void checkLNInt( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 4;                                                                                       // assume largest size
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '8' ) {                                                       // 8
+                lnth = 0;
+        } else if ( str[posn] == '1' ) {
+                posn += 1;
+                if ( str[posn] == '6' ) {                                               // 16
+                        lnth = 1;
+                } else {                                                                                // 128
+                        posn += 1;
+                        lnth = 5;
+                } // if
+        } else {
+                if ( str[posn] == '3' ) {                                               // 32
+                        lnth = 2;
+                } else if ( str[posn] == '6' ) {                                // 64
+                        lnth = 3;
+                } else {
+                        assertf( false, "internal error, bad integral length %s", str.c_str() );
+                } // if
+                posn += 1;
+        } // if
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNInt
 static void sepNumeric( string & str, string & units ) {
         string::size_type posn = str.find_first_of( "`" );
 …
 Expression * build_constantInteger( string & str ) {
         static const BasicType::Kind kind[2][5] = {
+        static const BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh)
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
+                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
         };
         string units;                                                                           // units
+        string units;
         sepNumeric( str, units );                                                       // separate constant from units
         bool dec = true, Unsigned = false;                                      // decimal, unsigned constant
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => size_t
+        int size;                                                                                       // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
+        int lnth = -1;                                                                          // literal length
         unsigned long long int v;                                                       // converted integral value
         size_t last = str.length() - 1;                                         // last character of constant
 …
                         } // if
                         str.erase( last - size - 1, size + 1 );         // remove 'h'/"hh"
+                } else {                                                                                // suffix "ln" ?
+                        checkLNInt( str, lnth, size );
                 } // if
         } else if ( checkL( str[ last ] ) ) {                           // suffix 'l' ?
 …
                 str.erase( last - size, size + 1 );                             // remove 'h'/"hh"
         } else if ( checkZ( str[last] ) ) {                                     // suffix 'z' ?
                 size = 5;
+                lnth = 4;
                 str.erase( last, 1 );                                                   // remove 'z'
+        } // if
+        } else {                                                                                        // suffix "ln" ?
+                checkLNInt( str, lnth, size );
+        } // if
+        assert( 0 <= size && size < 6 );
+        // Constant type is correct for overload resolving.
         ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[Unsigned][size] ), str, v ) );
         if ( Unsigned && size < 2 ) {                                           // less than int ?
                 // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which eliminates warnings for large values.
+        if ( Unsigned && size < 2 ) {                                           // hh or h, less than int ?
+                // int i = -1uh => 65535 not -1, so cast is necessary for unsigned, which unfortunately eliminates warnings for large values.
                 ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+        } else if ( size == 5 ) {                                                       // explicit cast to size_t
+                ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), "size_t", false ) );
+        } else if ( lnth != -1 ) {                                                      // explicit length ?
+                if ( lnth == 5 ) {                                                              // int128 ?
+                        size = 5;
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][size] ) );
+                } else {
+                        ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][lnth], false ) );
+                } // if
         } // if
   CLEANUP:
 …
         return ret;
 } // build_constantInteger
+static inline void checkLNFloat( string & str, int & lnth, int & size ) {
+        string::size_type posn = str.find_first_of( "lL" ), start = posn;
+  if ( posn == string::npos ) return;
+        size = 2;                                                                                       // assume largest size
+        lnth = 0;
+        posn += 1;                                                                                      // advance to size
+        if ( str[posn] == '3' ) {                                                       // 32
+                size = 0;
+        } else if ( str[posn] == '6' ) {                                        // 64
+                size = 1;
+        } else if ( str[posn] == '8' || str[posn] == '1' ) { // 80, 128
+                size = 2;
+                if ( str[posn] == '1' ) posn += 1;
+        } else {
+                assertf( false, "internal error, bad floating point length %s", str.c_str() );
+        } // if
+        posn += 1;
+        str.erase( start, posn - start + 1 );                           // remove length suffix
+} // checkLNFloat
 Expression * build_constantFloat( string & str ) {
 …
         };
         string units;                                                                           // units
+        string units;
         sepNumeric( str, units );                                                       // separate constant from units
         bool complx = false;                                                            // real, complex
+        int size = 1;                                                                           // 0 => float, 1 => double (default), 2 => long double
+        int size = 1;                                                                           // 0 => float, 1 => double, 2 => long double
+        int lnth = -1;                                                                          // literal length
         // floating-point constant has minimum of 2 characters: 1. or .1
         size_t last = str.length() - 1;
 …
         } else if ( checkL( str[last] ) ) {                                     // long double ?
                 size = 2;
+        } else {
+                size = 1;                                                                               // double (default)
+                checkLNFloat( str, lnth, size );
         } // if
         if ( ! complx && checkI( str[last - 1] ) ) {            // imaginary ?
 …
         } // if
+        assert( 0 <= size && size < 3 );
         Expression * ret = new ConstantExpr( Constant( new BasicType( noQualifiers, kind[complx][size] ), str, v ) );
+        if ( lnth != -1 ) {                                                                     // explicit length ?
+                ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[complx][size] ) );
+        } // if
         if ( units.length() != 0 ) {
                 ret = new UntypedExpr( new NameExpr( units ), { ret } );
 …
 NameExpr * build_varref( const string * name ) {
         NameExpr * expr = new NameExpr( *name, nullptr );
+        NameExpr * expr = new NameExpr( *name );
         delete name;
         return expr;
 …
         list< Expression * > args;
         buildMoveList( expr_node, args );
         return new UntypedExpr( maybeMoveBuild< Expression >(function), args, nullptr );
+        return new UntypedExpr( maybeMoveBuild< Expression >(function), args );
 } // build_func

src/Parser/ParseNode.h

-              r78315272
+              r3f7e12cb
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 14 23:09:39 2017
 // Update Count     : 815
+// Last Modified On : Sat Sep 23 18:11:22 2017
+// Update Count     : 821
 //
 …
 #define YYLTYPE_IS_DECLARED 1 /* alert the parser that we have our own definition */
-extern char * yyfilename;
-extern int yylineno;
 extern YYLTYPE yylloc;
 …
 class DeclarationNode : public ParseNode {
   public:
+        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
+        // These enumerations must harmonize with their names.
+        enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, Int128, Float80, Float128, NoBasicType };
+        static const char * basicTypeNames[];
         enum ComplexType { Complex, Imaginary, NoComplexType };
+        static const char * complexTypeNames[];
         enum Signedness { Signed, Unsigned, NoSignedness };
+        static const char * signednessNames[];
         enum Length { Short, Long, LongLong, NoLength };
+        static const char * lengthNames[];
         enum Aggregate { Struct, Union, Trait, Coroutine, Monitor, Thread, NoAggregate };
+        static const char * aggregateNames[];
         enum TypeClass { Otype, Dtype, Ftype, Ttype, NoTypeClass };
+        static const char * typeClassNames[];
         enum BuiltinType { Valist, Zero, One, NoBuiltinType };
-        static const char * basicTypeNames[];
-        static const char * complexTypeNames[];
-        static const char * signednessNames[];
-        static const char * lengthNames[];
-        static const char * aggregateNames[];
-        static const char * typeClassNames[];
         static const char * builtinTypeNames[];

src/Parser/StatementNode.cc

-              r78315272
+              r3f7e12cb
                 target,
                 maybeMoveBuild<Statement >( stmt ),
                 maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 …
         delete targetExpr;
         node->clauses.push_back( WaitForStmt::Clause{
+        node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{
                 std::move( target ),
                 maybeMoveBuild<Statement >( stmt ),
                 maybeMoveBuild<Expression>( when )
+                notZeroExpr( maybeMoveBuild<Expression>( when ) )
         });
 …
                 node->timeout.time      = maybeMoveBuild<Expression>( timeout );
                 node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
                 node->timeout.condition = maybeMoveBuild<Expression>( when    );
+                node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        }
         else {
                 node->orelse.statement  = maybeMoveBuild<Statement >( stmt    );
                 node->orelse.condition  = maybeMoveBuild<Expression>( when    );
+                node->orelse.statement  = maybeMoveBuild<Statement >( stmt );
+                node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( when ) );
+        }
 …
         node->timeout.time      = maybeMoveBuild<Expression>( timeout );
         node->timeout.statement = maybeMoveBuild<Statement >( stmt    );
         node->timeout.condition = maybeMoveBuild<Expression>( when    );
+        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
         node->orelse.statement = maybeMoveBuild<Statement >( else_stmt );
         node->orelse.condition = maybeMoveBuild<Expression>( else_when );
+        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
         return node;
+}
-// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) {
-//       return WaitForStmt::Clause{
-//       };
-// }
 Statement *build_compound( StatementNode *first ) {

src/Parser/TypeData.cc

-              r78315272
+              r3f7e12cb
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Sep  1 23:13:38 2017
 // Update Count     : 569
+// Last Modified On : Mon Sep 25 18:33:41 2017
+// Update Count     : 587
 //
 …
 } // TypeData::TypeData
 TypeData::~TypeData() {
         delete base;
 …
         } // switch
 } // TypeData::~TypeData
 TypeData * TypeData::clone() const {
 …
 } // TypeData::clone
 void TypeData::print( ostream &os, int indent ) const {
         for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
 …
 } // TypeData::print
 template< typename ForallList >
 void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
         buildList( firstNode, outputList );
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+        auto n = firstNode;
+        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
                 TypeDecl * td = static_cast<TypeDecl *>(*i);
                 if ( td->get_kind() == TypeDecl::Any ) {
+                if ( n->variable.tyClass == DeclarationNode::Otype ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
 …
                 } // if
         } // for
+}
+} // buildForall
 Type * typebuild( const TypeData * td ) {
 …
 } // typebuild
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
         TypeData * ret = nullptr;
 …
 } // typeextractAggregate
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
         return td->qualifiers;
 } // buildQualifiers
+static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
+        throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+} // genTSError
 Type * buildBasicType( const TypeData * td ) {
         BasicType::Kind ret;
 …
         switch ( td->basictype ) {
           case DeclarationNode::Void:
+                if ( td->signedness != DeclarationNode::NoSignedness && td->length != DeclarationNode::NoLength ) {
+                        throw SemanticError( "invalid type specifier \"void\" in type: ", td );
+                } // if
+                if ( td->signedness != DeclarationNode::NoSignedness ) {
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
+                } // if
+                if ( td->length != DeclarationNode::NoLength ) {
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                } // if
                 return new VoidType( buildQualifiers( td ) );
                 break;
 …
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
 …
                 if ( td->length != DeclarationNode::NoLength ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
 …
                 break;
+          case DeclarationNode::Int128:
+                ret = td->signedness == 1 ? BasicType::UnsignedInt128 : BasicType::SignedInt128;
+                if ( td->length != DeclarationNode::NoLength ) {
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
+                } // if
+                break;
           case DeclarationNode::Float:
+          case DeclarationNode::Float80:
+          case DeclarationNode::Float128:
           case DeclarationNode::Double:
           case DeclarationNode::LongDouble:                                     // not set until below
 …
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
+                        genTSError( DeclarationNode::signednessNames[ td->signedness ], td->basictype );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
                         throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
                         throw SemanticError( "invalid type specifier \"long\" in type: ", td );
+                        genTSError( DeclarationNode::lengthNames[ td->length ], td->basictype );
                 } // if
                 if ( td->length == DeclarationNode::Long ) {
 …
                 goto Integral;
           default:
                 assert(false);
+                assertf( false, "unknown basic type" );
                 return nullptr;
         } // switch
 …
         return bt;
 } // buildBasicType
 PointerType * buildPointer( const TypeData * td ) {
 …
         return pt;
 } // buildPointer
 ArrayType * buildArray( const TypeData * td ) {
 …
 } // buildArray
 ReferenceType * buildReference( const TypeData * td ) {
         ReferenceType * rt;
 …
 } // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Aggregate );
 …
         return at;
 } // buildAggregate
 ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 …
 } // buildAggInst
 ReferenceToType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
 …
 } // buildAggInst
 NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage ) {
         assert( td->kind == TypeData::Symbolic );
 …
                 ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage );
         } else {
                 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
+                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
         } // if
         buildList( td->symbolic.params, ret->get_parameters() );
 …
         return ret;
 } // buildSymbolic
 EnumDecl * buildEnum( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {
 …
 } // buildEnum
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
         assert( td->kind == TypeData::SymbolicInst );
 …
         return ret;
 } // buildSymbolicInst
 TupleType * buildTuple( const TypeData * td ) {
 …
 } // buildTuple
 TypeofType * buildTypeof( const TypeData * td ) {
         assert( td->kind == TypeData::Typeof );
 …
         return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
 } // buildTypeof
 Declaration * buildDecl( const TypeData * td, const string &name, Type::StorageClasses scs, Expression * bitfieldWidth, Type::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, Expression *asmName, Initializer * init, std::list< Attribute * > attributes ) {
 …
         return nullptr;
 } // buildDecl
 FunctionType * buildFunction( const TypeData * td ) {
 …
         return ft;
 } // buildFunction
 // Transform KR routine declarations into C99 routine declarations:

src/Parser/lex.ll

-              r78315272
+              r3f7e12cb
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Sun Sep 10 22:29:15 2017
  * Update Count     : 620
+ * Last Modified On : Wed Oct 25 13:53:56 2017
+ * Update Count     : 634
  */
 …
                                 // numeric constants, CFA: '_' in constant
 hex_quad {hex}("_"?{hex}){3}
+length ("ll"|"LL"|[lL])|("hh"|"HH"|[hH])
+size_opt (8|16|32|64|128)?
+length ("ll"|"LL"|[lL]{size_opt})|("hh"|"HH"|[hH])
 integer_suffix_opt ("_"?(([uU]({length}?[iI]?)|([iI]{length}))|([iI]({length}?[uU]?)|([uU]{length}))|({length}([iI]?[uU]?)|([uU][iI]))|[zZ]))?{user_suffix_opt}
 …
                                 // GCC: D (double) and iI (imaginary) suffixes, and DL (long double)
 exponent "_"?[eE]"_"?[+-]?{decimal_digits}
+floating_suffix ([fFdDlL]?[iI]?)|([iI][lLfFdD])
+floating_size 32|64|80|128
+floating_length ([fFdDlL]|[lL]{floating_size})
+floating_suffix ({floating_length}?[iI]?)|([iI]{floating_length})
 floating_suffix_opt ("_"?({floating_suffix}|"DL"))?{user_suffix_opt}
 decimal_digits ({decimal})|({decimal}({decimal}|"_")*{decimal})
 …
 __extension__   { KEYWORD_RETURN(EXTENSION); }                  // GCC
 extern                  { KEYWORD_RETURN(EXTERN); }
-fallthrough             { KEYWORD_RETURN(FALLTHRU); }                   // CFA
 fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA
+fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
 finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
+__float128              { KEYWORD_RETURN(FLOAT); }                              // GCC
+__float80               { KEYWORD_RETURN(FLOAT80); }                    // GCC
+float80                 { KEYWORD_RETURN(FLOAT80); }                    // GCC
+__float128              { KEYWORD_RETURN(FLOAT128); }                   // GCC
+float128                { KEYWORD_RETURN(FLOAT128); }                   // GCC
 for                             { KEYWORD_RETURN(FOR); }
 forall                  { KEYWORD_RETURN(FORALL); }                             // CFA
 …
 __inline__              { KEYWORD_RETURN(INLINE); }                             // GCC
 int                             { KEYWORD_RETURN(INT); }
 __int128                { KEYWORD_RETURN(INT); }                                // GCC
 __int128_t              { KEYWORD_RETURN(INT); }                                // GCC
+__int128                { KEYWORD_RETURN(INT128); }                             // GCC
+int128                  { KEYWORD_RETURN(INT128); }                             // GCC
 __label__               { KEYWORD_RETURN(LABEL); }                              // GCC
 long                    { KEYWORD_RETURN(LONG); }
 …
 __typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
 __typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
-__uint128_t             { KEYWORD_RETURN(INT); }                                // GCC
 union                   { KEYWORD_RETURN(UNION); }
 unsigned                { KEYWORD_RETURN(UNSIGNED); }

src/Parser/parser.yy

-              r78315272
+              r3f7e12cb
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Sep 14 23:07:12 2017
 // Update Count     : 2815
+// Last Modified On : Wed Oct 25 12:28:54 2017
+// Update Count     : 2893
 //
 …
 #define YYDEBUG_LEXER_TEXT (yylval)                                             // lexer loads this up each time
 #define YYDEBUG 1                                                                               // get the pretty debugging code to compile
 #define YYERROR_VERBOSE
+#define YYERROR_VERBOSE                                                                 // more information in syntax errors
 #undef __GNUC_MINOR__
 …
 bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
+# define YYLLOC_DEFAULT(Cur, Rhs, N)                            \
+do                                                              \
+        if (N) {                                                      \
+                (Cur).first_line   = YYRHSLOC(Rhs, 1).first_line;           \
+                (Cur).first_column = YYRHSLOC(Rhs, 1).first_column;         \
+                (Cur).last_line    = YYRHSLOC(Rhs, N).last_line;            \
+                (Cur).last_column  = YYRHSLOC(Rhs, N).last_column;          \
+                (Cur).filename     = YYRHSLOC(Rhs, 1).filename;             \
+        } else {                                                      \
+                (Cur).first_line   = (Cur).last_line   =                    \
+                        YYRHSLOC(Rhs, 0).last_line;                               \
+                (Cur).first_column = (Cur).last_column =                    \
+                        YYRHSLOC(Rhs, 0).last_column;                             \
+                (Cur).filename     = YYRHSLOC(Rhs, 0).filename;             \
+        }                                                             \
+while (0)
+// https://www.gnu.org/software/bison/manual/bison.html#Location-Type
+#define YYLLOC_DEFAULT(Cur, Rhs, N)                                                                                             \
+if ( N ) {                                                                                                                                              \
+        (Cur).first_line   = YYRHSLOC( Rhs, 1 ).first_line;                                                     \
+        (Cur).first_column = YYRHSLOC( Rhs, 1 ).first_column;                                           \
+        (Cur).last_line    = YYRHSLOC( Rhs, N ).last_line;                                                      \
+        (Cur).last_column  = YYRHSLOC( Rhs, N ).last_column;                                            \
+        (Cur).filename     = YYRHSLOC( Rhs, 1 ).filename;                                                       \
+} else {                                                                                                                                                \
+        (Cur).first_line   = (Cur).last_line = YYRHSLOC( Rhs, 0 ).last_line;            \
+        (Cur).first_column = (Cur).last_column = YYRHSLOC( Rhs, 0 ).last_column;        \
+        (Cur).filename     = YYRHSLOC( Rhs, 0 ).filename;                                                       \
+}
 %}
 %define parse.error verbose
 // Types declaration
+// Types declaration for productions
 %union
+{
 …
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
+%token INT128 FLOAT80 FLOAT128                                                  // GCC
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
 …
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 %token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA
+%token CHOOSE DISABLE ENABLE FALLTHRU FALLTHROUGH TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 %token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
 …
 %type<sn> exception_statement                   handler_clause                          finally_clause
 %type<catch_kind> handler_key
+%type<sn> mutex_statement
 %type<en> when_clause                                   when_clause_opt                         waitfor                                         timeout
 %type<sn> waitfor_statement
 …
 %precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
 %locations
+%locations                      // support location tracking for error messages
 %start translation_unit                                                                 // parse-tree root
 …
         | '(' compound_statement ')'                                            // GCC, lambda expression
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
-        | primary_expression '{' argument_expression_list '}' // CFA, constructor call
+                {
-                        Token fn;
-                        fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
-                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
                 { $$ = nullptr; }                                                               // FIX ME
+                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
                 { $$ = nullptr; }                                                               // FIX ME
+                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; }                                                          // FIX ME
+        ;
 …
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
+        | postfix_expression '{' argument_expression_list '}' // CFA, constructor call
+                {
+                        Token fn;
+                        fn.str = new std::string( "?{}" );                      // location undefined - use location of '{'?
+                        $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | postfix_expression '(' argument_expression_list ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
 …
         | jump_statement
         | with_statement
+        | mutex_statement
         | waitfor_statement
         | exception_statement
 …
+        ;
+fall_through_name:                                                                              // CFA
+        FALLTHRU
+        | FALLTHROUGH
+        ;
 fall_through:                                                                                   // CFA
         FALLTHRU
+        fall_through_name
                 { $$ = nullptr; }
         | FALLTHRU ';'
+        | fall_through_name ';'
                 { $$ = nullptr; }
+        ;
 …
+        ;
+// If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
+mutex_statement:
+        MUTEX '(' argument_expression_list ')' statement
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
 when_clause:
         WHEN '(' comma_expression ')'
 …
         | VOLATILE
                 { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
-        | MUTEX
-                { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); }
         | ATOMIC
                 { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
 …
 basic_type_name:
+        CHAR
+        VOID
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+        | BOOL                                                                                          // C99
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+        | CHAR
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+        | INT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+        | INT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int128 ); }
+        | FLOAT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+        | FLOAT80
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
+        | FLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
         | DOUBLE
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+        | FLOAT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+        | INT
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+        | LONG
+                { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
+        | SHORT
+                { $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+        | COMPLEX                                                                                       // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+        | IMAGINARY                                                                                     // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
         | SIGNED
                 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
         | UNSIGNED
                 { $$ = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
+        | VOID
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+        | BOOL                                                                                          // C99
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+        | COMPLEX                                                                                       // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+        | IMAGINARY                                                                                     // C99
+                { $$ = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+        | SHORT
+                { $$ = DeclarationNode::newLength( DeclarationNode::Short ); }
+        | LONG
+                { $$ = DeclarationNode::newLength( DeclarationNode::Long ); }
         | ZERO_T
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::Zero ); }
 …
         | TYPEDEFname
         | TYPEGENname
+        | FALLTHROUGH
+                { $$ = Token{ new string( "fallthrough" ), { nullptr, -1 } }; }
         | CONST
                 { $$ = Token{ new string( "__const__" ), { nullptr, -1 } }; }
 …
         paren_identifier attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        | '&' MUTEX paren_identifier attribute_list_opt
+                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | identifier_parameter_ptr
         | identifier_parameter_array attribute_list_opt
 …
 //
 //              typedef int foo;
+//              forall( otype T ) struct foo;
 //              int f( int foo ); // redefine typedef name in new scope
 //
 …
         typedef attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
+        | '&' MUTEX typedef attribute_list_opt
+                { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | type_parameter_ptr
         | type_parameter_array attribute_list_opt
 …
 abstract_parameter_declarator:
         abstract_parameter_ptr
+        | '&' MUTEX attribute_list_opt
+                { $$ = DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf )->addQualifiers( $3 ); }
         | abstract_parameter_array attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }

src/Parser/parserutility.cc

r78315272	r3f7e12cb
29	29
30	30	Expression notZeroExpr( Expression orig ) {
	31	if( !orig ) return nullptr;
31	32	UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
32	33	comparison->get_args().push_back( orig );

src/ResolvExpr/AdjustExprType.cc

-              r78315272
+              r3f7e12cb
 //
+#include "Common/PassVisitor.h"
 #include "SymTab/Indexer.h"       // for Indexer
 #include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
 …
 namespace ResolvExpr {
+        class AdjustExprType : public Mutator {
+                typedef Mutator Parent;
+                using Parent::mutate;
+        class AdjustExprType : public WithShortCircuiting {
           public:
                 AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );
+                void premutate( VoidType * ) { visit_children = false; }
+                void premutate( BasicType * ) { visit_children = false; }
+                void premutate( PointerType * ) { visit_children = false; }
+                void premutate( ArrayType * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
+                void premutate( StructInstType * ) { visit_children = false; }
+                void premutate( UnionInstType * ) { visit_children = false; }
+                void premutate( EnumInstType * ) { visit_children = false; }
+                void premutate( TraitInstType * ) { visit_children = false; }
+                void premutate( TypeInstType * ) { visit_children = false; }
+                void premutate( TupleType * ) { visit_children = false; }
+                void premutate( VarArgsType * ) { visit_children = false; }
+                void premutate( ZeroType * ) { visit_children = false; }
+                void premutate( OneType * ) { visit_children = false; }
+                Type * postmutate( ArrayType *arrayType );
+                Type * postmutate( FunctionType *functionType );
+                Type * postmutate( TypeInstType *aggregateUseType );
           private:
-                virtual Type* mutate( VoidType *voidType );
-                virtual Type* mutate( BasicType *basicType );
-                virtual Type* mutate( PointerType *pointerType );
-                virtual Type* mutate( ArrayType *arrayType );
-                virtual Type* mutate( FunctionType *functionType );
-                virtual Type* mutate( StructInstType *aggregateUseType );
-                virtual Type* mutate( UnionInstType *aggregateUseType );
-                virtual Type* mutate( EnumInstType *aggregateUseType );
-                virtual Type* mutate( TraitInstType *aggregateUseType );
-                virtual Type* mutate( TypeInstType *aggregateUseType );
-                virtual Type* mutate( TupleType *tupleType );
-                virtual Type* mutate( VarArgsType *varArgsType );
-                virtual Type* mutate( ZeroType *zeroType );
-                virtual Type* mutate( OneType *oneType );
                 const TypeEnvironment &env;
                 const SymTab::Indexer &indexer;
 …
         void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
                 AdjustExprType adjuster( env, indexer );
+                PassVisitor<AdjustExprType> adjuster( env, indexer );
                 Type *newType = type->acceptMutator( adjuster );
                 type = newType;
 …
+        }
+        Type *AdjustExprType::mutate( VoidType *voidType ) {
+                return voidType;
+        }
+        Type *AdjustExprType::mutate( BasicType *basicType ) {
+                return basicType;
+        }
+        Type *AdjustExprType::mutate( PointerType *pointerType ) {
+                return pointerType;
+        }
+        Type *AdjustExprType::mutate( ArrayType *arrayType ) {
+                // need to recursively mutate the base type in order for multi-dimensional arrays to work.
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ) );
+        Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
+                arrayType->base = nullptr;
                 delete arrayType;
                 return pointerType;
+        }
+        Type *AdjustExprType::mutate( FunctionType *functionType ) {
+                PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
+                return pointerType;
+        Type * AdjustExprType::postmutate( FunctionType * functionType ) {
+                return new PointerType( Type::Qualifiers(), functionType );
+        }
+        Type *AdjustExprType::mutate( StructInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( UnionInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( EnumInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
+        Type *AdjustExprType::mutate( TypeInstType *typeInst ) {
+        Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
                 EqvClass eqvClass;
                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
 …
                 return typeInst;
+        }
-        Type *AdjustExprType::mutate( TupleType *tupleType ) {
-                return tupleType;
+        }
-        Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
-                return varArgsType;
+        }
-        Type *AdjustExprType::mutate( ZeroType *zeroType ) {
-                return zeroType;
+        }
-        Type *AdjustExprType::mutate( OneType *oneType ) {
-                return oneType;
+        }
 } // namespace ResolvExpr

src/ResolvExpr/Alternative.cc

-              r78315272
+              r3f7e12cb
+        }
         void Alternative::print( std::ostream &os, int indent ) const {
                 os << std::string( indent, ' ' ) << "Cost " << cost << ": ";
+        void Alternative::print( std::ostream &os, Indenter indent ) const {
+                os << "Cost " << cost << ": ";
                 if ( expr ) {
                         expr->print( os, indent );
                         os << "(types:" << std::endl;
                         os << std::string( indent+4, ' ' );
                         expr->get_result()->print( os, indent + 4 );
                         os << std::endl << ")" << std::endl;
+                        expr->print( os, indent+1 );
+                        os << std::endl << indent << "(types:" << std::endl;
+                        os << indent+1;
+                        expr->result->print( os, indent+1 );
+                        os << std::endl << indent << ")" << std::endl;
                 } else {
                         os << "Null expression!" << std::endl;
                 } // if
                 os << std::string( indent, ' ' ) << "Environment: ";
                 env.print( os, indent+2 );
+                os << indent << "Environment: ";
+                env.print( os, indent+1 );
                 os << std::endl;
+        }

src/ResolvExpr/Alternative.h

r78315272	r3f7e12cb
39	39	~Alternative();
40	40
41		void print( std::ostream &os, ~~int indent = 0~~ ) const;
	41	void print( std::ostream &os, Indenter indent = {} ) const;
42	42
43	43	Cost cost;

src/ResolvExpr/AlternativeFinder.cc

-              r78315272
+              r3f7e12cb
         namespace {
+                void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
+                void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt = 0 ) {
+                        Indenter indent = { Indenter::tabsize, indentAmt };
                         for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
                                 i->print( os, indent );
 …
+                                                )
                                                 mapPlace->second.isAmbiguous = true;
+                                        } else {
+                                                PRINT(
+                                                        std::cerr << "cost " << candidate->cost << " loses to " << mapPlace->second.candidate->cost << std::endl;
+                                                )
+                                        }
                                 } else {
 …
+                                }
+                        }
-                        PRINT(
-                                std::cerr << "there are " << selected.size() << " alternatives before elimination" << std::endl;
+                        )
                         // accept the alternatives that were unambiguous
 …
                         expr->get_result()->accept( global_renamer );
+                }
-                void referenceToRvalueConversion( Expression *& expr ) {
-                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
-                                // cast away reference from expr
-                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        }
+                }
         } // namespace
+        void referenceToRvalueConversion( Expression *& expr ) {
+                if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                        // cast away reference from expr
+                        expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                }
+        }
         template< typename InputIterator, typename OutputIterator >
 …
+        }
         void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) {
+        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) {
                 expr->accept( *this );
                 if ( alternatives.empty() ) {
+                if ( failFast && alternatives.empty() ) {
                         throw SemanticError( "No reasonable alternatives for expression ", expr );
+                }
-                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
-                        if ( adjust ) {
-                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                        }
+                }
                 if ( prune ) {
+                        auto oldsize = alternatives.size();
                         PRINT(
                                 std::cerr << "alternatives before prune:" << std::endl;
 …
                         AltList::iterator oldBegin = alternatives.begin();
                         pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
                         if ( alternatives.begin() == oldBegin ) {
+                        if ( failFast && alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
                                 AltList winners;
                                 findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
                                 stream << "Cannot choose between " << winners.size() << " alternatives for expression ";
+                                stream << "Cannot choose between " << winners.size() << " alternatives for expression\n";
                                 expr->print( stream );
                                 stream << "Alternatives are:";
                                 printAlts( winners, stream, 8 );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
                                 throw SemanticError( stream.str() );
+                        }
                         alternatives.erase( oldBegin, alternatives.end() );
+                        PRINT(
+                                std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
+                        )
                         PRINT(
                                 std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
+                        )
+                }
+                // adjust types after pruning so that types substituted by pruneAlternatives are correctly adjusted
+                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
+                        if ( adjust ) {
+                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                        }
+                }
 …
+        }
+        void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) {
+                find( expr, true, prune );
+        void AlternativeFinder::findWithAdjustment( Expression *expr ) {
+                find( expr, true );
+        }
+        void AlternativeFinder::findWithoutPrune( Expression * expr ) {
+                find( expr, true, false );
+        }
+        void AlternativeFinder::maybeFind( Expression * expr ) {
+                find( expr, true, true, false );
+        }
 …
                 Cost convCost = conversionCost( actualType, formalType, indexer, env );
                 PRINT(
                         std::cerr << std::endl << "cost is" << convCost << std::endl;
+                        std::cerr << std::endl << "cost is " << convCost << std::endl;
+                )
                 if ( convCost == Cost::infinity ) {
 …
+                }
                 convCost.incPoly( polyCost( formalType, env, indexer ) + polyCost( actualType, env, indexer ) );
+                PRINT(
+                        std::cerr << "cost with polycost is " << convCost << std::endl;
+                )
                 return convCost;
+        }
 …
         Cost computeExpressionConversionCost( Expression *& actualExpr, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
                 Cost convCost = computeConversionCost( actualExpr->result, formalType, indexer, env );
+                // if ( convCost != Cost::zero ) {
+                // xxx - temporary -- ignore poly cost, since this causes some polymorphic functions to be cast, which causes the specialize
+                // pass to try to specialize them, which currently does not work. Once that is fixed, remove the next 3 lines and uncomment the
+                // previous line.
+                // if there is a non-zero conversion cost, ignoring poly cost, then the expression requires conversion.
+                // ignore poly cost for now, since this requires resolution of the cast to infer parameters and this
+                // does not currently work for the reason stated below.
                 Cost tmpCost = convCost;
                 tmpCost.incPoly( -tmpCost.get_polyCost() );
 …
                                 if ( function->get_isVarArgs() ) {
                                         convCost.incUnsafe();
+                                        PRINT( std::cerr << "end of formals with varargs function: inc unsafe: " << convCost << std::endl; ; )
                                         // convert reference-typed expressions to value-typed expressions
                                         referenceToRvalueConversion( *actualExpr );
 …
+                        }
                         Type * formalType = (*formal)->get_type();
-                        PRINT(
-                                std::cerr << std::endl << "converting ";
-                                actualType->print( std::cerr, 8 );
-                                std::cerr << std::endl << " to ";
-                                formalType->print( std::cerr, 8 );
-                                std::cerr << std::endl << "environment is: ";
-                                alt.env.print( std::cerr, 8 );
-                                std::cerr << std::endl;
+                        )
                         convCost += computeExpressionConversionCost( *actualExpr, formalType, indexer, alt.env );
                         ++formal; // can't be in for-loop update because of the continue
 …
                                 Alternative newerAlt( newAlt );
                                 newerAlt.env = newEnv;
                                 assert( (*candidate)->get_uniqueId() );
+                                assertf( (*candidate)->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( *candidate ).c_str() );
                                 DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
 …
                                         std::cerr << std::endl;
+                                )
-                                ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
                                 // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter).
                                 InferredParams * inferParameters = &appExpr->get_inferParams();
+                                InferredParams * inferParameters = &newerAlt.expr->get_inferParams();
                                 for ( UniqueId id : cur->second.idChain ) {
                                         inferParameters = (*inferParameters)[ id ].inferParams.get();
 …
                 return ! results.empty();
+        }
+        }
         template<typename OutputIterator>
         void AlternativeFinder::makeFunctionAlternatives( const Alternative& func,
                         FunctionType* funcType, const std::vector< AlternativeFinder >& args,
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
+                        FunctionType *funcType, const std::vector< AlternativeFinder > &args,
                         OutputIterator out ) {
                 OpenVarSet funcOpenVars;
                 AssertionSet funcNeed, funcHave;
                 TypeEnvironment funcEnv;
+                TypeEnvironment funcEnv( func.env );
                 makeUnifiableVars( funcType, funcOpenVars, funcNeed );
                 // add all type variables as open variables now so that those not used in the parameter
                 // list are still considered open.
                 funcEnv.add( funcType->get_forall() );
                 if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
                         // attempt to narrow based on expected target type
                         Type* returnType = funcType->get_returnVals().front()->get_type();
+                        Type * returnType = funcType->get_returnVals().front()->get_type();
                         if ( ! unify( returnType, targetType, funcEnv, funcNeed, funcHave, funcOpenVars,
                                         indexer ) ) {
 …
                 // find function operators
+                static NameExpr *opExpr = new NameExpr( "?()" );
                 AlternativeFinder funcOpFinder( indexer, env );
+                NameExpr *opExpr = new NameExpr( "?()" );
+                try {
+                        funcOpFinder.findWithAdjustment( opExpr );
+                } catch( SemanticError &e ) {
+                        // it's ok if there aren't any defined function ops
+                }
+                // it's ok if there aren't any defined function ops
+                funcOpFinder.maybeFind( opExpr);
                 PRINT(
                         std::cerr << "known function ops:" << std::endl;
                         printAlts( funcOpFinder.alternatives, std::cerr, 8 );
+                        printAlts( funcOpFinder.alternatives, std::cerr, 1 );
+                )
 …
         bool isLvalue( Expression *expr ) {
                 // xxx - recurse into tuples?
                 return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+                return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+        }
 …
                                 thisCost.incSafe( discardedValues );
                                 Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
+                                // xxx - this doesn't work at the moment, since inferParameters requires an ApplicationExpr as the alternative.
+                                // Once this works, it should be possible to infer parameters on a cast expression and specialize any function.
+                                // inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                candidates.emplace_back( std::move( newAlt ) );
+                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
                         } // if
                 } // for
 …
                 AlternativeFinder finder( indexer, env );
                 // don't prune here, since it's guaranteed all alternatives will have the same type
+                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
+                finder.findWithAdjustment( castExpr->get_arg(), false );
+                finder.findWithoutPrune( castExpr->get_arg() );
                 for ( Alternative & alt : finder.alternatives ) {
                         alternatives.push_back( Alternative(
 …
                 PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
+                        VariableExpr newExpr( *i );
                         alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
 …
                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
                 std::list< AltList > possibilities;
-                // TODO re-write to use iterative method
                 combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
                 for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
 …
                 // don't prune here, since it's guaranteed all alternatives will have the same type
                 // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
                 finder.findWithAdjustment( ctorExpr->get_callExpr(), false );
+                finder.findWithoutPrune( ctorExpr->get_callExpr() );
                 for ( Alternative & alt : finder.alternatives ) {
                         alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
 …
                 // O(N^2) checks of d-types with e-types
                 for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
                         Type * toType = resolveTypeof( initAlt.type, indexer );
+                        Type * toType = resolveTypeof( initAlt.type->clone(), indexer );
                         SymTab::validateType( toType, &indexer );
                         adjustExprType( toType, env, indexer );
 …
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
+                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                }
+                        }

src/ResolvExpr/AlternativeFinder.h

-              r78315272
+              r3f7e12cb
+                }
                 void find( Expression *expr, bool adjust = false, bool prune = true );
+                void find( Expression *expr, bool adjust = false, bool prune = true, bool failFast = true );
                 /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
+                void findWithAdjustment( Expression *expr, bool prune = true );
+                void findWithAdjustment( Expression *expr );
+                /// Calls find with the adjust flag set and prune flag unset; pruning ensures there is at most one alternative per result type
+                void findWithoutPrune( Expression *expr );
+                /// Calls find with the adjust and prune flags set, failFast flags unset; fail fast ensures that there is at least one resulting alternative
+                void maybeFind( Expression *expr );
                 AltList &get_alternatives() { return alternatives; }
 …
                 const SymTab::Indexer &get_indexer() const { return indexer; }
                 const TypeEnvironment &get_environ() const { return env; }
+                /// Runs a new alternative finder on each element in [begin, end)
+                /// and writes each alternative finder to out.
+                template< typename InputIterator, typename OutputIterator >
+                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
           private:
                 virtual void visit( ApplicationExpr *applicationExpr );
 …
                 virtual void visit( StmtExpr *stmtExpr );
                 virtual void visit( UntypedInitExpr *initExpr );
-                /// Runs a new alternative finder on each element in [begin, end)
-                /// and writes each alternative finder to out.
-                template< typename InputIterator, typename OutputIterator >
-                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
                 /// Adds alternatives for anonymous members
 …
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
+        void referenceToRvalueConversion( Expression *& expr );
         template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/CastCost.cc

-              r78315272
+              r3f7e12cb
 #include "typeops.h"                     // for typesCompatibleIgnoreQualifiers
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
 namespace ResolvExpr {
 …
                         } // if
                 } // if
+                PRINT(
+                        std::cerr << "castCost ::: src is ";
+                        src->print( std::cerr );
+                        std::cerr << std::endl << "dest is ";
+                        dest->print( std::cerr );
+                        std::cerr << std::endl << "env is" << std::endl;
+                        env.print( std::cerr, 8 );
+                )
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
+                        PRINT( std::cerr << "compatible!" << std::endl; )
                         return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
                         return Cost::safe;
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
                         return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
                                 return ptrsCastable( t1, t2, env, indexer );

src/ResolvExpr/CommonType.cc

-              r78315272
+              r3f7e12cb
 // Created On       : Sun May 17 06:59:27 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Mar 16 16:24:31 2017
 // Update Count     : 7
+// Last Modified On : Mon Sep 25 15:18:17 2017
+// Update Count     : 9
 //
 …
         };
         Type * handleReference( ReferenceType * refType, Type * other, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
                 Type * result = nullptr, * common = nullptr;
+        Type * handleReference( Type * t1, Type * t2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
+                Type * common = nullptr;
                 AssertionSet have, need;
                 OpenVarSet newOpen( openVars );
                 // need unify to bind type variables
+                if ( unify( refType->get_base(), other, env, have, need, newOpen, indexer, common ) ) {
+                        // std::cerr << "unify success" << std::endl;
+                        if ( widenSecond ) {
+                                // std::cerr << "widen second" << std::endl;
+                                if ( widenFirst || other->get_qualifiers() <= refType->get_qualifiers() ) {
+                                        result = new ReferenceType( refType->get_qualifiers(), common ); // refType->clone();
+                                        result->get_qualifiers() |= other->get_qualifiers();
+                                }
+                        } else if ( widenFirst ) {
+                                // std::cerr << "widen first" << std::endl;
+                                if ( widenSecond || refType->get_qualifiers() <= other->get_qualifiers() ) {
+                                        result = common;
+                                        result->get_qualifiers() |= refType->get_qualifiers();
+                                }
+                        }
+                } else {
+                        // std::cerr << "exact unify failed: " << refType << " " << other << std::endl;
+                }
+                // std::cerr << "common type of reference [" << refType << "] and non-reference [" << other << "] is [" << result << "]" << std::endl;
+                return result;
+                if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) {
+                        // std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
+                        if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) {
+                                // std::cerr << "widen okay" << std::endl;
+                                common->get_qualifiers() |= t1->get_qualifiers();
+                                common->get_qualifiers() |= t2->get_qualifiers();
+                                return common;
+                        }
+                }
+                // std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
+                return nullptr;
+        }
 …
                         // special case where one type has a reference depth of 1 larger than the other
+                        if ( diff > 0 ) {
+                                return handleReference( strict_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
+                        } else if ( diff < 0 ) {
+                                return handleReference( strict_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
+                        if ( diff > 0 || diff < 0 ) {
+                                Type * result = nullptr;
+                                if ( ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 ) ) {
+                                        // formal is reference, so result should be reference
+                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
+                                        if ( result ) result = new ReferenceType( ref1->get_qualifiers(), result );
+                                } else {
+                                        // formal is value, so result should be value
+                                        ReferenceType * ref2 = strict_dynamic_cast< ReferenceType * > ( type2 );
+                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
+                                }
+                                // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
+                                return result;
+                        }
                         // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
 …
         static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
+        {
+/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary */
+                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
+                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
+                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
+                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
+                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }
+/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary   SignedInt128   UnsignedInt128 */
+                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Float,       BasicType::Float, },
+                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Double,      BasicType::Double, },
+                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDouble,  BasicType::LongDouble, },
+                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::FloatComplex, },
+                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex, },
+                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex, },
+                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::FloatImaginary,      BasicType::FloatImaginary, },
+                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::DoubleImaginary,     BasicType::DoubleImaginary, },
+                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary },
+                /* SignedInt128 */      { BasicType::SignedInt128,      BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
+                /* UnsignedInt128 */    { BasicType::UnsignedInt128,    BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::UnsignedInt128,      BasicType::UnsignedInt128, },
         };

src/ResolvExpr/ConversionCost.cc

-              r78315272
+              r3f7e12cb
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  2 17:35:46 2016
 // Update Count     : 6
+// Last Modified On : Mon Sep 25 15:43:34 2017
+// Update Count     : 10
 //
 …
 namespace ResolvExpr {
         const Cost Cost::zero = Cost( 0, 0, 0, 0 );
         const Cost Cost::infinity = Cost( -1, -1, -1, -1 );
         const Cost Cost::unsafe = Cost( 1, 0, 0, 0 );
         const Cost Cost::poly = Cost( 0, 1, 0, 0 );
         const Cost Cost::safe = Cost( 0, 0, 1, 0 );
         const Cost Cost::reference = Cost( 0, 0, 0, 1 );
+        const Cost Cost::zero =      Cost(  0,  0,  0,  0 );
+        const Cost Cost::infinity =  Cost( -1, -1, -1, -1 );
+        const Cost Cost::unsafe =    Cost(  1,  0,  0,  0 );
+        const Cost Cost::poly =      Cost(  0,  1,  0,  0 );
+        const Cost Cost::safe =      Cost(  0,  0,  1,  0 );
+        const Cost Cost::reference = Cost(  0,  0,  0,  1 );
 #if 0
 …
                                         int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
                                         if ( assignResult < 0 ) {
+                                        if ( assignResult > 0 ) {
                                                 return Cost::safe;
                                         } else if ( assignResult > 0 ) {
+                                        } else if ( assignResult < 0 ) {
                                                 return Cost::unsafe;
                                         } // if
 …
 */
+        static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
+        {
+        /* Src \ Dest:  Bool    Char    SChar   UChar   Short   UShort  Int     UInt    Long    ULong   LLong   ULLong  Float   Double  LDbl    FCplex  DCplex  LDCplex FImag   DImag   LDImag */
+                /* Bool */      { 0,    1,              1,              2,              3,              4,              5,              6,              6,              7,              8,              9,              10,             11,             12,             11,             12,             13,             -1,             -1,             -1 },
+                /* Char */      { -1,   0,              -1,             1,              2,              3,              4,              5,              5,              6,              7,              8,              9,              10,             11,             10,             11,             12,             -1,             -1,             -1 },
+                /* SChar */ { -1,       -1,             0,              1,              2,              3,              4,              5,              5,              6,              7,              8,              9,              10,             11,             10,             11,             12,             -1,             -1,             -1 },
+                /* UChar */ { -1,       -1,             -1,             0,              1,              2,              3,              4,              4,              5,              6,              7,              8,              9,              10,             9,              10,             11,             -1,             -1,             -1 },
+                /* Short */ { -1,       -1,             -1,             -1,             0,              1,              2,              3,              3,              4,              5,              6,              7,              8,              9,              8,              9,              10,             -1,             -1,             -1 },
+                /* UShort */{ -1,       -1,             -1,             -1,             -1,             0,              1,              2,              2,              3,              4,              5,              6,              7,              8,              7,              8,              9,              -1,             -1,             -1 },
+                /* Int */       { -1,   -1,             -1,             -1,             -1,             -1,             0,              1,              1,              2,              3,              4,              5,              6,              7,              6,              7,              8,              -1,             -1,             -1 },
+                /* UInt */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             1,              2,              3,              4,              5,              6,              5,              6,              7,              -1,             -1,             -1 },
+                /* Long */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              4,              5,              6,              5,              6,              7,              -1,             -1,             -1 },
+                /* ULong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              4,              5,              4,              5,              6,              -1,             -1,             -1 },
+                /* LLong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              4,              3,              4,              5,              -1,             -1,             -1 },
+                /* ULLong */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              2,              3,              4,              -1,             -1,             -1 },
+                /* Float */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              1,              2,              3,              -1,             -1,             -1 },
+                /* Double */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             1,              2,              -1,             -1,             -1 },
+                /* LDbl */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             1,              -1,             -1,             -1 },
+                /* FCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              -1,             -1,             -1 },
+                /* DCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             -1,             -1 },
+                /* LDCplex */{ -1,      -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             -1 },
+                /* FImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              0,              1,              2 },
+                /* DImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              -1,             0,              1 },
+                /* LDImag */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             0 }
+        static const int costMatrix[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] = {
+        /* Src \ Dest:  Bool    Char    SChar   UChar   Short   UShort  Int     UInt    Long    ULong   LLong   ULLong  Float   Double  LDbl    FCplex  DCplex  LDCplex FImag   DImag   LDImag  I128,   U128 */
+                /* Bool */      { 0,    1,              1,              2,              3,              4,              5,              6,              6,              7,              8,              9,              12,             13,             14,             12,             13,             14,             -1,             -1,             -1,             10,             11,     },
+                /* Char */      { -1,   0,              -1,             1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,     },
+                /* SChar */ { -1,       -1,             0,              1,              2,              3,              4,              5,              5,              6,              7,              8,              11,             12,             13,             11,             12,             13,             -1,             -1,             -1,             9,              10,     },
+                /* UChar */ { -1,       -1,             -1,             0,              1,              2,              3,              4,              4,              5,              6,              7,              10,             11,             12,             10,             11,             12,             -1,             -1,             -1,             8,              9,      },
+                /* Short */ { -1,       -1,             -1,             -1,             0,              1,              2,              3,              3,              4,              5,              6,              9,              10,             11,             9,              10,             11,             -1,             -1,             -1,             7,              8,      },
+                /* UShort */{ -1,       -1,             -1,             -1,             -1,             0,              1,              2,              2,              3,              4,              5,              8,              9,              10,             8,              9,              10,             -1,             -1,             -1,             6,              7,      },
+                /* Int */       { -1,   -1,             -1,             -1,             -1,             -1,             0,              1,              1,              2,              3,              4,              7,              8,              9,              7,              8,              9,              -1,             -1,             -1,             5,              6,      },
+                /* UInt */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,      },
+                /* Long */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              3,              6,              7,              8,              6,              7,              8,              -1,             -1,             -1,             4,              5,      },
+                /* ULong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              5,              6,              7,              5,              6,              7,              -1,             -1,             -1,             3,              4,      },
+                /* LLong */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              4,              5,              6,              4,              5,              6,              -1,             -1,             -1,             2,              3,      },
+                /* ULLong */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              3,              4,              5,              3,              4,              5,              -1,             -1,             -1,             1,              2,      },
+                /* Float */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              1,              2,              3,              -1,             -1,             -1,             -1,             -1,     },
+                /* Double */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             1,              2,              -1,             -1,             -1,             -1,             -1,     },
+                /* LDbl */      { -1,   -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             1,              -1,             -1,             -1,             -1,             -1,     },
+                /* FCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              2,              -1,             -1,             -1,             -1,             -1,     },
+                /* DCplex */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              1,              -1,             -1,             -1,             -1,             -1,     },
+                /* LDCplex */{ -1,      -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             0,              -1,             -1,             -1,             -1,             -1,     },
+                /* FImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              0,              1,              2,              -1,             -1,     },
+                /* DImag */ { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              -1,             0,              1,              -1,             -1,     },
+                /* LDImag */{ -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              -1,             -1,             0,              -1,             -1,     },
+                /* I128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             2,              3,              4,              3,              4,              5,              -1,             -1,             -1,             0,              1,      },
+                /* U128 */  { -1,       -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             -1,             1,              2,              3,              2,              3,              4,              -1,             -1,             -1,             -1,             0,      },
         };
 …
+        }
         void ConversionCost::visit(PointerType *pointerType) {
+        void ConversionCost::visit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
 …
+                                }
                         } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
                                 int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
+                                int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
                                 PRINT( std::cerr << " :: " << assignResult << std::endl; )
                                 if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
+                                if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
                                         cost = Cost::safe;
                                 } else if ( assignResult > 0 ) {
+                                } else if ( assignResult < 0 ) {
                                         cost = Cost::unsafe;
                                 } // if
                                 // assignResult == 0 means Cost::Infinity
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
+                } else if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::unsafe;
                 } // if
+        }
         void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
         void ConversionCost::visit(ReferenceType *refType) {
+        void ConversionCost::visit( ArrayType * ) {}
+        void ConversionCost::visit( ReferenceType * refType ) {
                 // Note: dest can never be a reference, since it would have been caught in an earlier check
                 assert( ! dynamic_cast< ReferenceType * >( dest ) );
 …
                 // recursively compute conversion cost from T1 to T2.
                 // cv can be safely dropped because of 'implicit dereference' behavior.
                 refType->get_base()->accept( *this );
                 if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) {
+                refType->base->accept( *this );
+                if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
                         cost.incReference();  // prefer exact qualifiers
                 } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) {
+                } else if ( refType->base->get_qualifiers() < dest->get_qualifiers() ) {
                         cost.incSafe(); // then gaining qualifiers
                 } else {
 …
+        }
         void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
         void ConversionCost::visit(StructInstType *inst) {
+        void ConversionCost::visit( FunctionType * ) {}
+        void ConversionCost::visit( StructInstType * inst ) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->get_name() == destAsInst->get_name() ) {
                                 cost = Cost::zero;
                         } // if
                 } // if
+        }
         void ConversionCost::visit(UnionInstType *inst) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->get_name() == destAsInst->get_name() ) {
                                 cost = Cost::zero;
                         } // if
                 } // if
+        }
         void ConversionCost::visit( __attribute((unused)) EnumInstType *inst ) {
+                        if ( inst->name == destAsInst->name ) {
+                                cost = Cost::zero;
+                        } // if
+                } // if
+        }
+        void ConversionCost::visit( UnionInstType * inst ) {
+                if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
+                        if ( inst->name == destAsInst->name ) {
+                                cost = Cost::zero;
+                        } // if
+                } // if
+        }
+        void ConversionCost::visit( EnumInstType * ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
 …
+        }
+        void ConversionCost::visit( __attribute((unused)) TraitInstType *inst) {
+        }
+        void ConversionCost::visit(TypeInstType *inst) {
+        void ConversionCost::visit( TraitInstType * ) {}
+        void ConversionCost::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 NamedTypeDecl *namedType;
 …
+        }
         void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
+        void ConversionCost::visit( TupleType * tupleType ) {
                 Cost c = Cost::zero;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
                         std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
                         std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
+                if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
+                        std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
+                        std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
                         while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
                                 Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
 …
+        }
         void ConversionCost::visit( __attribute((unused)) VarArgsType *varArgsType) {
+        void ConversionCost::visit( VarArgsType * ) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
 …
+        }
         void ConversionCost::visit( __attribute((unused)) ZeroType *zeroType) {
                 if ( dynamic_cast< ZeroType* >( dest ) ) {
+        void ConversionCost::visit( ZeroType * ) {
+                if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::zero;
                 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
 …
+        }
         void ConversionCost::visit( __attribute((unused)) OneType *oneType) {
                 if ( dynamic_cast< OneType* >( dest ) ) {
+        void ConversionCost::visit( OneType * ) {
+                if ( dynamic_cast< OneType * >( dest ) ) {
                         cost = Cost::zero;
                 } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {

src/ResolvExpr/CurrentObject.cc

r78315272	r3f7e12cb
260	260
261	261	AggregateIterator( const std::string & kind, const std::string & name, Type * inst, const MemberList & members ) : kind( kind ), name( name ), inst( inst ), members( members ), curMember( members.begin() ), sub( makeGenericSubstitution( inst ) ) {
	262	PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
262	263	init();
263	264	}

src/ResolvExpr/PolyCost.cc

-              r78315272
+              r3f7e12cb
 // file "LICENCE" distributed with Cforall.
 //
 // PolyCost.cc --
+// PolyCost.cc --
 //
 // Author           : Richard C. Bilson
 …
         };
         int polyCost( Type *type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+        int polyCost( Type *type, const TypeEnvironment & env, const SymTab::Indexer &indexer ) {
                 PolyCost coster( env, indexer );
                 type->accept( coster );
 …
+        }
         PolyCost::PolyCost( const TypeEnvironment &env, const SymTab::Indexer &indexer ) : result( 0 ), env( env ), indexer( indexer ) {
+        PolyCost::PolyCost( const TypeEnvironment & env, const SymTab::Indexer & indexer ) : result( 0 ), env( env ), indexer( indexer ) {
+        }
         void PolyCost::visit(TypeInstType *typeInst) {
+        void PolyCost::visit(TypeInstType * typeInst) {
                 EqvClass eqvClass;
                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                if ( env.lookup( typeInst->name, eqvClass ) ) {
                         if ( eqvClass.type ) {
+                                if ( TypeInstType *otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {
+                                        if ( indexer.lookupType( otherTypeInst->get_name() ) ) {
+                                if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {
+                                        if ( indexer.lookupType( otherTypeInst->name ) ) {
+                                                // bound to opaque type
                                                 result += 1;
                                         } // if
                                 } else {
+                                        // bound to concrete type
                                         result += 1;
                                 } // if

src/ResolvExpr/PtrsAssignable.cc

-              r78315272
+              r3f7e12cb
         int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env ) {
+                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
                         EqvClass eqvClass;
 …
                 } // if
                 if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return 1;
+                        // void * = T * for any T is unsafe
+                        // xxx - this should be safe, but that currently breaks the build
+                        return -1;
                 } else {
                         PtrsAssignable ptrs( dest, env );
 …
         void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
                 if ( dynamic_cast< FunctionType* >( dest ) ) {
                         result = 0;
                 } else {
                         result = -1;
+                if ( ! dynamic_cast< FunctionType* >( dest ) ) {
+                        // T * = void * is safe for any T that is not a function type.
+                        // xxx - this should be unsafe...
+                        result = 1;
                 } // if
+        }
 …
         void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
         void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {
+                result = -1;
+        }
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {}
         void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
 …
         void PtrsAssignable::visit( EnumInstType * ) {
+                if ( dynamic_cast< EnumInstType* >( dest ) ) {
+                if ( dynamic_cast< BasicType* >( dest ) ) {
+                        // int * = E *, etc. is safe. This isn't technically correct, as each
+                        // enum has one basic type that it is compatible with, an that type can
+                        // differ from enum to enum. Without replicating GCC's internal logic,
+                        // there is no way to know which type this particular enum is compatible
+                        // with, so punt on this for now.
                         result = 1;
-                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
-                        result = bt->get_kind() == BasicType::SignedInt;
+                }
+        }
 …
                 EqvClass eqvClass;
                 if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
+                        // T * = S * for any S depends on the type bound to T
                         result = ptrsAssignable( eqvClass.type, dest, env );
-                } else {
-                        result = 0;
                 } // if
+        }

src/ResolvExpr/PtrsCastable.cc

-              r78315272
+              r3f7e12cb
         };
+        int objectCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                if ( dynamic_cast< FunctionType* >( src ) ) {
+                        return -1;
+                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
+                        EqvClass eqvClass;
+                        if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
+                                if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
+                                        if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
+        namespace {
+                int objectCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                        if ( dynamic_cast< FunctionType* >( src ) ) {
+                                return -1;
+                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
+                                EqvClass eqvClass;
+                                if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
+                                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
+                                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
+                                                        return -1;
+                                                } // if
+                                        } //if
+                                } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                                        if ( eqvClass.data.kind == TypeDecl::Ftype ) {
                                                 return -1;
                                         } // if
-                                } //if
-                        } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
-                                if ( eqvClass.data.kind == TypeDecl::Ftype ) {
-                                        return -1;
                                 } // if
                         } // if
                 } //if
                 return 1;
+        }
         int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
                 return -1 * objectCast( src, env, indexer );  // reverse the sense of objectCast
+                        } //if
+                        return 1;
+                }
+                int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                        return -1 * objectCast( src, env, indexer );  // reverse the sense of objectCast
+                }
+        }
 …
+        }
         void PtrsCastable::visit( __attribute__((unused)) VoidType *voidType) {
+        void PtrsCastable::visit( VoidType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) BasicType *basicType) {
+        void PtrsCastable::visit( BasicType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) PointerType *pointerType) {
+        void PtrsCastable::visit( PointerType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) ArrayType *arrayType) {
+        void PtrsCastable::visit( ArrayType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) FunctionType *functionType) {
+        void PtrsCastable::visit( FunctionType * ) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) StructInstType *inst) {
+        void PtrsCastable::visit( StructInstType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) UnionInstType *inst) {
+        void PtrsCastable::visit( UnionInstType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) EnumInstType *inst) {
+        void PtrsCastable::visit( EnumInstType * ) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
 …
+        }
         void PtrsCastable::visit( __attribute__((unused)) TraitInstType *inst ) {}
+        void PtrsCastable::visit( TraitInstType * ) {}
         void PtrsCastable::visit(TypeInstType *inst) {
 …
+        }
         void PtrsCastable::visit( __attribute__((unused)) TupleType *tupleType) {
+        void PtrsCastable::visit( TupleType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) VarArgsType *varArgsType) {
+        void PtrsCastable::visit( VarArgsType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) ZeroType *zeroType) {
+        void PtrsCastable::visit( ZeroType * ) {
                 result = objectCast( dest, env, indexer );
+        }
         void PtrsCastable::visit( __attribute__((unused)) OneType *oneType) {
+        void PtrsCastable::visit( OneType * ) {
                 result = objectCast( dest, env, indexer );
+        }

src/ResolvExpr/ResolveTypeof.cc

-              r78315272
+              r3f7e12cb
 #include <cassert>               // for assert
+#include "Common/PassVisitor.h"  // for PassVisitor
 #include "Resolver.h"            // for resolveInVoidContext
 #include "SynTree/Expression.h"  // for Expression
 …
+        }
         class ResolveTypeof : public Mutator {
+        class ResolveTypeof : public WithShortCircuiting {
           public:
                 ResolveTypeof( const SymTab::Indexer &indexer ) : indexer( indexer ) {}
+                Type *mutate( TypeofType *typeofType );
+                void premutate( TypeofType *typeofType );
+                Type * postmutate( TypeofType *typeofType );
           private:
 …
         };
         Type *resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
                 ResolveTypeof mutator( indexer );
+        Type * resolveTypeof( Type *type, const SymTab::Indexer &indexer ) {
+                PassVisitor<ResolveTypeof> mutator( indexer );
                 return type->acceptMutator( mutator );
+        }
+        Type *ResolveTypeof::mutate( TypeofType *typeofType ) {
+        void ResolveTypeof::premutate( TypeofType * ) {
+                visit_children = false;
+        }
+        Type * ResolveTypeof::postmutate( TypeofType *typeofType ) {
 #if 0
                 std::cout << "resolving typeof: ";
                 typeofType->print( std::cout );
                 std::cout << std::endl;
+                std::cerr << "resolving typeof: ";
+                typeofType->print( std::cerr );
+                std::cerr << std::endl;
 #endif
                 if ( typeofType->get_expr() ) {
                         Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
                         assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
                         Type *newType = newExpr->get_result();
                         newExpr->set_result( nullptr );
+                if ( typeofType->expr ) {
+                        Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
+                        assert( newExpr->result && ! newExpr->result->isVoid() );
+                        Type * newType = newExpr->result;
+                        newExpr->result = nullptr;
                         delete typeofType;
                         delete newExpr;

src/ResolvExpr/Resolver.cc

-              r78315272
+              r3f7e12cb
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 using namespace std;
 …
                 void previsit( FunctionDecl *functionDecl );
                 void postvisit( FunctionDecl *functionDecl );
                 void previsit( ObjectDecl *functionDecl );
+                void previsit( ObjectDecl *objectDecll );
                 void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
 …
                 void previsit( ThrowStmt *throwStmt );
                 void previsit( CatchStmt *catchStmt );
+                void previsit( WaitForStmt * stmt );
                 void previsit( SingleInit *singleInit );
 …
+        }
+        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+                PassVisitor<Resolver> resolver( indexer );
+                maybeAccept( decl, resolver );
+        }
         // used in resolveTypeof
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
 …
         namespace {
                 void finishExpr( Expression *expr, const TypeEnvironment &env ) {
                         expr->set_env( new TypeSubstitution );
+                void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                        expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->get_env() );
+                }
+                void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
+                                        // cast is to the same type as its argument, so it's unnecessary -- remove it
+                                        expr = castExpr->arg;
+                                        castExpr->arg = nullptr;
+                                        std::swap( expr->env, castExpr->env );
+                                        delete castExpr;
+                                }
+                        }
+                }
         } // namespace
         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                 global_renamer.reset();
                 TypeEnvironment env;
                 Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                finishExpr( newExpr, env );
+                return newExpr;
+                finishExpr( newExpr, env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
+        }
+        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
+                if ( ! untyped ) return;
+                TypeEnvironment env;
+                AlternativeFinder finder( indexer, env );
+                finder.find( untyped );
+                #if 0
+                if ( finder.get_alternatives().size() != 1 ) {
+                        std::cerr << "untyped expr is ";
+                        untyped->print( std::cerr );
+                        std::cerr << std::endl << "alternatives are:";
+                        for ( const Alternative & alt : finder.get_alternatives() ) {
+                                alt.print( std::cerr );
+                        } // for
+                } // if
+                #endif
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                Alternative &choice = finder.get_alternatives().front();
+                Expression *newExpr = choice.expr->clone();
+                finishExpr( newExpr, choice.env, untyped->env );
+                delete untyped;
+                untyped = newExpr;
+        }
+        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
+                assert( untyped && type );
+                untyped = new CastExpr( untyped, type );
+                findSingleExpression( untyped, indexer );
+                removeExtraneousCast( untyped, indexer );
+        }
         namespace {
-                Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
-                        Alternative &choice = finder.get_alternatives().front();
-                        Expression *newExpr = choice.expr->clone();
-                        finishExpr( newExpr, choice.env );
-                        return newExpr;
+                }
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
 …
+                }
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
                         AlternativeFinder finder( indexer, env );
 …
                                 throw SemanticError( "No interpretations for case control expression", untyped );
                         } // if
+                        finishExpr( newExpr, *newEnv );
+                        return newExpr;
+                        finishExpr( newExpr, *newEnv, untyped->env );
+                        delete untyped;
+                        untyped = newExpr;
+                }
 …
         void Resolver::handlePtrType( PtrType * type ) {
                 if ( type->get_dimension() ) {
+                        CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, indexer );
+                        delete type->get_dimension();
+                        type->set_dimension( newExpr );
+                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
+                }
+        }
 …
                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+        }
         void Resolver::postvisit( FunctionDecl *functionDecl ) {
 …
         void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
+                assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
+                Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
+                delete exprStmt->get_expr();
+                exprStmt->set_expr( newExpr );
+                assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
+                findVoidExpression( exprStmt->expr, indexer );
+        }
         void Resolver::previsit( AsmExpr *asmExpr ) {
                 visit_children = false;
+                Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
+                delete asmExpr->get_operand();
+                asmExpr->set_operand( newExpr );
+                findVoidExpression( asmExpr->operand, indexer );
                 if ( asmExpr->get_inout() ) {
+                        newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
+                        delete asmExpr->get_inout();
+                        asmExpr->set_inout( newExpr );
+                        findVoidExpression( asmExpr->inout, indexer );
                 } // if
+        }
 …
         void Resolver::previsit( IfStmt *ifStmt ) {
+                Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
+                delete ifStmt->get_condition();
+                ifStmt->set_condition( newExpr );
+                findSingleExpression( ifStmt->condition, indexer );
+        }
         void Resolver::previsit( WhileStmt *whileStmt ) {
+                Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
+                delete whileStmt->get_condition();
+                whileStmt->set_condition( newExpr );
+                findSingleExpression( whileStmt->condition, indexer );
+        }
         void Resolver::previsit( ForStmt *forStmt ) {
+                if ( forStmt->get_condition() ) {
+                        Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
+                        delete forStmt->get_condition();
+                        forStmt->set_condition( newExpr );
+                if ( forStmt->condition ) {
+                        findSingleExpression( forStmt->condition, indexer );
                 } // if
+                if ( forStmt->get_increment() ) {
+                        Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
+                        delete forStmt->get_increment();
+                        forStmt->set_increment( newExpr );
+                if ( forStmt->increment ) {
+                        findVoidExpression( forStmt->increment, indexer );
                 } // if
+        }
 …
         void Resolver::previsit( SwitchStmt *switchStmt ) {
                 GuardValue( currentObject );
+                Expression *newExpr;
+                newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
+                delete switchStmt->get_condition();
+                switchStmt->set_condition( newExpr );
+                currentObject = CurrentObject( newExpr->get_result() );
+                findIntegralExpression( switchStmt->condition, indexer );
+                currentObject = CurrentObject( switchStmt->condition->result );
+        }
 …
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
+                        CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
+                        Expression * newExpr = findSingleExpression( castExpr, indexer );
+                        castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
+                        caseStmt->set_condition( castExpr->get_arg() );
+                        castExpr->set_arg( nullptr );
+                        // must remove cast from case statement because RangeExpr cannot be cast.
+                        Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
+                        findSingleExpression( newExpr, indexer );
+                        CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
+                        caseStmt->condition = castExpr->arg;
+                        castExpr->arg = nullptr;
                         delete castExpr;
+                }
 …
                 // must resolve the argument for a computed goto
                 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
+                        if ( Expression * arg = branchStmt->get_computedTarget() ) {
+                                VoidType v = Type::Qualifiers();                // cast to void * for the alternative finder
+                                PointerType pt( Type::Qualifiers(), v.clone() );
+                                CastExpr * castExpr = new CastExpr( arg, pt.clone() );
+                                Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
+                                branchStmt->set_target( newExpr );
+                        if ( branchStmt->computedTarget ) {
+                                // computed goto argument is void *
+                                findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
                         } // if
                 } // if
 …
         void Resolver::previsit( ReturnStmt *returnStmt ) {
                 visit_children = false;
+                if ( returnStmt->get_expr() ) {
+                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
+                        Expression *newExpr = findSingleExpression( castExpr, indexer );
+                        delete castExpr;
+                        returnStmt->set_expr( newExpr );
+                if ( returnStmt->expr ) {
+                        findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
                 } // if
+        }
 …
                                 indexer.lookupStruct( "__cfaehm__base_exception_t" );
                         assert( exception_decl );
+                        Expression * wrapped = new CastExpr(
+                                throwStmt->get_expr(),
+                                new PointerType(
+                                        noQualifiers,
+                                        new StructInstType(
+                                                noQualifiers,
+                                                exception_decl
+                                                )
+                                        )
+                                );
+                        Expression * newExpr = findSingleExpression( wrapped, indexer );
+                        throwStmt->set_expr( newExpr );
+                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
+                        findSingleExpression( throwStmt->expr, exceptType, indexer );
+                }
+        }
         void Resolver::previsit( CatchStmt *catchStmt ) {
+                if ( catchStmt->get_cond() ) {
+                        Expression * wrapped = new CastExpr(
+                                catchStmt->get_cond(),
+                                new BasicType( noQualifiers, BasicType::Bool )
+                                );
+                        catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
+                if ( catchStmt->cond ) {
+                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
+                }
+        }
+        template< typename iterator_t >
+        inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
+                while( it != end && !(*it)->get_type()->get_mutex() ) {
+                        it++;
+                }
+                return it != end;
+        }
+        void Resolver::previsit( WaitForStmt * stmt ) {
+                visit_children = false;
+                // Resolve all clauses first
+                for( auto& clause : stmt->clauses ) {
+                        TypeEnvironment env;
+                        AlternativeFinder funcFinder( indexer, env );
+                        // Find all alternatives for a function in canonical form
+                        funcFinder.findWithAdjustment( clause.target.function );
+                        if ( funcFinder.get_alternatives().empty() ) {
+                                stringstream ss;
+                                ss << "Use of undeclared indentifier '";
+                                ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
+                                ss << "' in call to waitfor";
+                                throw SemanticError( ss.str() );
+                        }
+                        // Find all alternatives for all arguments in canonical form
+                        std::list< AlternativeFinder > argAlternatives;
+                        funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
+                        // List all combinations of arguments
+                        std::list< AltList > possibilities;
+                        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+                        AltList                func_candidates;
+                        std::vector< AltList > args_candidates;
+                        // For every possible function :
+                        //      try matching the arguments to the parameters
+                        //      not the other way around because we have more arguments than parameters
+                        SemanticError errors;
+                        for ( Alternative & func : funcFinder.get_alternatives() ) {
+                                try {
+                                        PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
+                                        if( !pointer ) {
+                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                        }
+                                        FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                        if( !function ) {
+                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                        }
+                                        {
+                                                auto param     = function->parameters.begin();
+                                                auto param_end = function->parameters.end();
+                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                }
+                                        }
+                                        Alternative newFunc( func );
+                                        // Strip reference from function
+                                        referenceToRvalueConversion( newFunc.expr );
+                                        // For all the set of arguments we have try to match it with the parameter of the current function alternative
+                                        for ( auto & argsList : possibilities ) {
+                                                try {
+                                                        // Declare data structures need for resolution
+                                                        OpenVarSet openVars;
+                                                        AssertionSet resultNeed, resultHave;
+                                                        TypeEnvironment resultEnv;
+                                                        // Load type variables from arguemnts into one shared space
+                                                        simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
+                                                        // Make sure we don't widen any existing bindings
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
+                                                        // Find any unbound type variables
+                                                        resultEnv.extractOpenVars( openVars );
+                                                        auto param     = function->parameters.begin();
+                                                        auto param_end = function->parameters.end();
+                                                        // For every arguments of its set, check if it matches one of the parameter
+                                                        // The order is important
+                                                        for( auto & arg : argsList ) {
+                                                                // Ignore non-mutex arguments
+                                                                if( !advance_to_mutex( param, param_end ) ) {
+                                                                        // We ran out of parameters but still have arguments
+                                                                        // this function doesn't match
+                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                }
+                                                                // Check if the argument matches the parameter type in the current scope
+                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
+                                                                        // Type doesn't match
+                                                                        stringstream ss;
+                                                                        ss << "candidate function not viable: no known convertion from '";
+                                                                        arg.expr->get_result()->print( ss );
+                                                                        ss << "' to '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "'\n";
+                                                                        throw SemanticError(ss.str(), function);
+                                                                }
+                                                                param++;
+                                                        }
+                                                        // All arguments match !
+                                                        // Check if parameters are missing
+                                                        if( advance_to_mutex( param, param_end ) ) {
+                                                                // We ran out of arguments but still have parameters left
+                                                                // this function doesn't match
+                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                        }
+                                                        // All parameters match !
+                                                        // Finish the expressions to tie in the proper environments
+                                                        finishExpr( newFunc.expr, resultEnv );
+                                                        for( Alternative & alt : argsList ) {
+                                                                finishExpr( alt.expr, resultEnv );
+                                                        }
+                                                        // This is a match store it and save it for later
+                                                        func_candidates.push_back( newFunc );
+                                                        args_candidates.push_back( argsList );
+                                                }
+                                                catch( SemanticError &e ) {
+                                                        errors.append( e );
+                                                }
+                                        }
+                                }
+                                catch( SemanticError &e ) {
+                                        errors.append( e );
+                                }
+                        }
+                        // Make sure we got the right number of arguments
+                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+                        // Swap the results from the alternative with the unresolved values.
+                        // Alternatives will handle deletion on destruction
+                        std::swap( clause.target.function, func_candidates.front().expr );
+                        for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
+                                std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
+                        }
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        findSingleExpression( clause.condition, this->indexer );
+                        clause.statement->accept( *visitor );
+                }
+                if( stmt->timeout.statement ) {
+                        // Resolve the timeout as an size_t for now
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
+                        findSingleExpression( stmt->timeout.condition, this->indexer );
+                        stmt->timeout.statement->accept( *visitor );
+                }
+                if( stmt->orelse.statement ) {
+                        // Resolve the conditions as if it were an IfStmt
+                        // Resolve the statments normally
+                        findSingleExpression( stmt->orelse.condition, this->indexer );
+                        stmt->orelse.statement->accept( *visitor );
+                }
+        }
 …
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
                 Expression * newExpr = findSingleExpression( untyped, indexer );
+                Expression * newExpr = new UntypedInitExpr( singleInit->value, currentObject.getOptions() );
+                findSingleExpression( newExpr, indexer );
                 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 …
                 // discard InitExpr wrapper and retain relevant pieces
                 newExpr = initExpr->get_expr();
                 newExpr->set_env( initExpr->get_env() );
                 initExpr->set_expr( nullptr );
                 initExpr->set_env( nullptr );
+                newExpr = initExpr->expr;
+                initExpr->expr = nullptr;
+                std::swap( initExpr->env, newExpr->env );
+                std::swap( initExpr->inferParams, newExpr->inferParams ) ;
                 delete initExpr;
                 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
                 Type * initContext = currentObject.getCurrentType();
+                removeExtraneousCast( newExpr, indexer );
                 // check if actual object's type is char[]
 …
                                 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
                                         if ( isCharType( pt->get_base() ) ) {
+                                                // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr );
+                                                newExpr = ce->get_arg();
+                                                ce->set_arg( nullptr );
+                                                delete ce;
+                                                if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
+                                                        newExpr = ce->get_arg();
+                                                        ce->set_arg( nullptr );
+                                                        std::swap( ce->env, newExpr->env );
+                                                        delete ce;
+                                                }
+                                        }
+                                }
 …
                 // set initializer expr to resolved express
                 singleInit->set_value( newExpr );
+                singleInit->value = newExpr;
                 // move cursor to next object in preparation for next initializer

src/ResolvExpr/Resolver.h

-              r78315272
+              r3f7e12cb
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
+        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
+        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
+        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );

src/ResolvExpr/TypeEnvironment.cc

-              r78315272
+              r3f7e12cb
+        }
         void EqvClass::print( std::ostream &os, int indent ) const {
                 os << std::string( indent, ' ' ) << "( ";
+        void EqvClass::print( std::ostream &os, Indenter indent ) const {
+                os << "( ";
                 std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
                 os << ")";
                 if ( type ) {
                         os << " -> ";
                         type->print( os, indent );
+                        type->print( os, indent+1 );
                 } // if
                 if ( ! allowWidening ) {
 …
                 for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
                         for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) {
 ///       std::cout << "adding " << *theVar;
+///       std::cerr << "adding " << *theVar;
                                 if ( theClass->type ) {
 ///         std::cout << " bound to ";
 ///         theClass->type->print( std::cout );
 ///         std::cout << std::endl;
+///         std::cerr << " bound to ";
+///         theClass->type->print( std::cerr );
+///         std::cerr << std::endl;
                                         sub.add( *theVar, theClass->type );
                                 } else if ( theVar != theClass->vars.begin() ) {
                                         TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
 ///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
+///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
                                         sub.add( *theVar, newTypeInst );
                                         delete newTypeInst;
 …
+        }
         void TypeEnvironment::print( std::ostream &os, int indent ) const {
+        void TypeEnvironment::print( std::ostream &os, Indenter indent ) const {
                 for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
                         i->print( os, indent );

src/ResolvExpr/TypeEnvironment.h

-              r78315272
+              r3f7e12cb
                 EqvClass &operator=( const EqvClass &other );
                 ~EqvClass();
                 void print( std::ostream &os, int indent = 0 ) const;
+                void print( std::ostream &os, Indenter indent = {} ) const;
         };
 …
                 void makeSubstitution( TypeSubstitution &result ) const;
                 bool isEmpty() const { return env.empty(); }
                 void print( std::ostream &os, int indent = 0 ) const;
+                void print( std::ostream &os, Indenter indent = {} ) const;
                 void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) );
                 void simpleCombine( const TypeEnvironment &second );

src/ResolvExpr/Unify.cc

-              r78315272
+              r3f7e12cb
 #include <iterator>               // for back_insert_iterator, back_inserter
 #include <map>                    // for _Rb_tree_const_iterator, _Rb_tree_i...
 #include <memory>                 // for unique_ptr, auto_ptr
+#include <memory>                 // for unique_ptr
 #include <set>                    // for set
 #include <string>                 // for string, operator==, operator!=, bas...
 #include <utility>                // for pair
+#include "Common/PassVisitor.h"   // for PassVisitor
 #include "FindOpenVars.h"         // for findOpenVars
 #include "Parser/LinkageSpec.h"   // for C
 …
         bool tyVarCompatible( const TypeDecl::Data & data, Type *type ) {
                 switch ( data.kind ) {
-                  case TypeDecl::Any:
                   case TypeDecl::Dtype:
                         // to bind to an object type variable, the type must not be a function type.
 …
                                 Type *common = 0;
                                 // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
                                 std::auto_ptr< Type > newType( curClass.type->clone() );
+                                std::unique_ptr< Type > newType( curClass.type->clone() );
                                 newType->get_qualifiers() = typeInst->get_qualifiers();
                                 if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
 …
                 if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() ) {
-                        // not positive this is correct in all cases, but it's needed for typedefs
-                        if ( arrayType->get_isVarLen() || otherArray->get_isVarLen() ) {
-                                return;
+                        }
                         if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() &&
                                 arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0 ) {
 …
         /// If this isn't done then argument lists can have wildly different
         /// size and structure, when they should be compatible.
+        struct TtypeExpander : public Mutator {
+                TypeEnvironment & env;
+                TtypeExpander( TypeEnvironment & env ) : env( env ) {}
+                Type * mutate( TypeInstType * typeInst ) {
+        struct TtypeExpander : public WithShortCircuiting {
+                TypeEnvironment & tenv;
+                TtypeExpander( TypeEnvironment & tenv ) : tenv( tenv ) {}
+                void premutate( TypeInstType * ) { visit_children = false; }
+                Type * postmutate( TypeInstType * typeInst ) {
                         EqvClass eqvClass;
                         if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                        if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
                                 if ( eqvClass.data.kind == TypeDecl::Ttype ) {
                                         // expand ttype parameter into its actual type
 …
                 dst.clear();
                 for ( DeclarationWithType * dcl : src ) {
                         TtypeExpander expander( env );
+                        PassVisitor<TtypeExpander> expander( env );
                         dcl->acceptMutator( expander );
                         std::list< Type * > types;
 …
                         std::list<Type *> types1, types2;
                         TtypeExpander expander( env );
+                        PassVisitor<TtypeExpander> expander( env );
                         flat1->acceptMutator( expander );
                         flat2->acceptMutator( expander );

src/SymTab/Autogen.cc

-              r78315272
+              r3f7e12cb
 #include "Autogen.h"
-#include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
 …
 #include "AddVisit.h"              // for addVisit
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
+#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
+#include "InitTweak/GenInit.h"     // for fixReturnStatements
+#include "ResolvExpr/Resolver.h"   // for resolveDecl
 #include "SymTab/Mangler.h"        // for Mangler
 #include "SynTree/Attribute.h"     // For Attribute
 …
 namespace SymTab {
         Type * SizeType = 0;
+        typedef ScopedMap< std::string, bool > TypeMap;
+        /// Data used to generate functions generically. Specifically, the name of the generated function, a function which generates the routine protoype, and a map which contains data to determine whether a function should be generated.
+        /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
         struct FuncData {
                 typedef FunctionType * (*TypeGen)( Type * );
                 FuncData( const std::string & fname, const TypeGen & genType, TypeMap & map ) : fname( fname ), genType( genType ), map( map ) {}
+                FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
                 std::string fname;
                 TypeGen genType;
+                TypeMap & map;
+        };
+        class AutogenerateRoutines final : public Visitor {
+            template< typename Visitor >
+            friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+            template< typename Visitor >
+            friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
+          public:
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+                typedef Visitor Parent;
+                using Parent::visit;
+        };
+        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting, public WithIndexer {
                 AutogenerateRoutines();
+                virtual void visit( EnumDecl *enumDecl );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TraitDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
+                void previsit( EnumDecl * enumDecl );
+                void previsit( StructDecl * structDecl );
+                void previsit( UnionDecl * structDecl );
+                void previsit( TypeDecl * typeDecl );
+                void previsit( TraitDecl * traitDecl );
+                void previsit( FunctionDecl * functionDecl );
+                void previsit( FunctionType * ftype );
+                void previsit( PointerType * ptype );
+                void previsit( CompoundStmt * compoundStmt );
           private:
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                std::set< std::string > structsDone;
+                GenPoly::ScopedSet< std::string > structsDone;
                 unsigned int functionNesting = 0;     // current level of nested functions
+                /// Note: the following maps could be ScopedSets, but it should be easier to work
+                /// deleted functions in if they are maps, since the value false can be inserted
+                /// at the current scope without affecting outer scopes or requiring copies.
+                TypeMap copyable, assignable, constructable, destructable;
+                InitTweak::ManagedTypes managedTypes;
                 std::vector< FuncData > data;
         };
         /// generates routines for tuple types.
+        /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit
+        /// or anything we currently have that supports adding new declarations for visitors
+        class AutogenTupleRoutines : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+                using Parent::mutate;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+                virtual Type * mutate( TupleType *tupleType );
+                virtual CompoundStmt * mutate( CompoundStmt *compoundStmt );
+        struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef<AutogenTupleRoutines>, public WithGuards, public WithShortCircuiting {
+                void previsit( FunctionDecl * functionDecl );
+                void postvisit( TupleType * tupleType );
+                void previsit( CompoundStmt * compoundStmt );
           private:
 …
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
                 AutogenerateRoutines generator;
                 acceptAndAdd( translationUnit, generator );
+                PassVisitor<AutogenerateRoutines> generator;
+                acceptAll( translationUnit, generator );
                 // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
                 // AutogenTupleRoutines tupleGenerator;
+                // tupleGenerator.mutateDeclarationList( translationUnit );
+                // acceptAll( translationUnit, tupleGenerator );
+        }
+        //=============================================================================================
+        // FuncGenerator definitions
+        //=============================================================================================
+        class FuncGenerator {
+        public:
+                std::list< Declaration * > definitions, forwards;
+                FuncGenerator( Type * type, const std::vector< FuncData > & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : type( type ), data( data ), functionNesting( functionNesting ), indexer( indexer ) {}
+                virtual bool shouldAutogen() const = 0;
+                void genStandardFuncs();
+                virtual void genFieldCtors() = 0;
+        protected:
+                Type * type;
+                const std::vector< FuncData > & data;
+                unsigned int functionNesting;
+                SymTab::Indexer & indexer;
+                virtual void genFuncBody( FunctionDecl * dcl ) = 0;
+                virtual bool isConcurrentType() const = 0;
+                void resolve( FunctionDecl * dcl );
+                void generatePrototypes( std::list< FunctionDecl * > & newFuncs );
+        };
+        class StructFuncGenerator : public FuncGenerator {
+                StructDecl * aggregateDecl;
+        public:
+                StructFuncGenerator( StructDecl * aggregateDecl, StructInstType * refType, const std::vector< FuncData > & data,  unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), aggregateDecl( aggregateDecl) {}
+                virtual bool shouldAutogen() const override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual void genFieldCtors() override;
+        private:
+                /// generates a single struct member operation (constructor call, destructor call, assignment call)
+                void makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true );
+                /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
+                template<typename Iterator>
+                void makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true );
+                /// generate the body of a constructor which takes parameters that match fields, e.g.
+                /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+                template<typename Iterator>
+                void makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func );
+        };
+        class UnionFuncGenerator : public FuncGenerator {
+                UnionDecl * aggregateDecl;
+        public:
+                UnionFuncGenerator( UnionDecl * aggregateDecl, UnionInstType * refType, const std::vector< FuncData > & data,  unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), aggregateDecl( aggregateDecl) {}
+                virtual bool shouldAutogen() const override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual void genFieldCtors() override;
+        private:
+                /// generates a single struct member operation (constructor call, destructor call, assignment call)
+                template<typename OutputIterator>
+                void makeMemberOp( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out );
+                /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
+                template<typename Iterator>
+                void makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true );
+                /// generate the body of a constructor which takes parameters that match fields, e.g.
+                /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+                template<typename Iterator>
+                void makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func );
+        };
+        class EnumFuncGenerator : public FuncGenerator {
+        public:
+                EnumFuncGenerator( EnumInstType * refType, const std::vector< FuncData > & data,  unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ) {}
+                virtual bool shouldAutogen() const override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual void genFieldCtors() override;
+        private:
+        };
+        class TypeFuncGenerator : public FuncGenerator {
+                TypeDecl * typeDecl;
+        public:
+                TypeFuncGenerator( TypeDecl * typeDecl, TypeInstType * refType, const std::vector<FuncData> & data, unsigned int functionNesting, SymTab::Indexer & indexer ) : FuncGenerator( refType, data, functionNesting, indexer ), typeDecl( typeDecl ) {}
+                virtual bool shouldAutogen() const override;
+                virtual void genFuncBody( FunctionDecl * dcl ) override;
+                virtual bool isConcurrentType() const override;
+                virtual void genFieldCtors() override;
+        };
+        //=============================================================================================
+        // helper functions
+        //=============================================================================================
+        void generateFunctions( FuncGenerator & gen, std::list< Declaration * > & declsToAdd ) {
+                if ( ! gen.shouldAutogen() ) return;
+                // generate each of the functions based on the supplied FuncData objects
+                gen.genStandardFuncs();
+                gen.genFieldCtors();
+                declsToAdd.splice( declsToAdd.end(), gen.forwards );
+                declsToAdd.splice( declsToAdd.end(), gen.definitions );
+        }
         bool isUnnamedBitfield( ObjectDecl * obj ) {
                 return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
+                return obj != nullptr && obj->name == "" && obj->bitfieldWidth != nullptr;
+        }
 …
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
                 decl->set_statements( NULL );
+                delete decl->statements;
+                decl->statements = nullptr;
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
+        }
+        const std::list< TypeDecl * > getGenericParams( Type * t ) {
+                std::list< TypeDecl * > * ret = nullptr;
+                if ( StructInstType * inst = dynamic_cast< StructInstType * > ( t ) ) {
+                        ret = inst->get_baseParameters();
+                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
+                        ret = inst->get_baseParameters();
+                }
+                return ret ? *ret : std::list< TypeDecl * >();
+        }
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType ) {
+                const auto & typeParams = getGenericParams( paramType );
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
+                cloneAll( typeParams, ftype->forall );
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
+                ftype->get_parameters().push_back( dstParam );
+                ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
 …
                 FunctionType *ftype = genDefaultType( paramType );
                 ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->get_parameters().push_back( srcParam );
+                ftype->parameters.push_back( srcParam );
                 return ftype;
+        }
 …
                 FunctionType *ftype = genCopyType( paramType );
                 ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->get_returnVals().push_back( returnVal );
+                ftype->returnVals.push_back( returnVal );
                 return ftype;
+        }
 …
+        }
+        /// inserts base type of first argument into map if pred(funcDecl) is true
+        void insert( FunctionDecl *funcDecl, TypeMap & map, FunctionDecl * (*pred)(Declaration *) ) {
+                // insert type into constructable, etc. map if appropriate
+                if ( pred( funcDecl ) ) {
+                        FunctionType * ftype = funcDecl->get_functionType();
+                        assert( ! ftype->get_parameters().empty() );
+                        Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() );
+                        assert( t );
+                        map.insert( Mangler::mangleType( t ), true );
+                }
+        }
+        /// using map and t, determines if is constructable, etc.
+        bool lookup( const TypeMap & map, Type * t ) {
+                assertf( t, "Autogenerate lookup was given non-type: %s", toString( t ).c_str() );
+                if ( dynamic_cast< PointerType * >( t ) ) {
+                        // will need more complicated checking if we want this to work with pointer types, since currently
+                        return true;
+                } else if ( ArrayType * at = dynamic_cast< ArrayType * >( t ) ) {
+                        // an array's constructor, etc. is generated on the fly based on the base type's constructor, etc.
+                        return lookup( map, at->get_base() );
+                }
+                TypeMap::const_iterator it = map.find( Mangler::mangleType( t ) );
+                if ( it != map.end() ) return it->second;
+                // something that does not appear in the map is by default not constructable, etc.
+                return false;
+        }
+        /// using map and aggr, examines each member to determine if constructor, etc. should be generated
+        template<typename Container>
+        bool shouldGenerate( const TypeMap & map, const Container & container ) {
+                for ( Type * t : container ) {
+                        if ( ! lookup( map, t ) ) return false;
+                }
+                return true;
+        }
+        /// data structure for abstracting the generation of special functions
+        template< typename OutputIterator, typename Container >
+        struct FuncGenerator {
+                const Container & container;
+                Type *refType;
+                unsigned int functionNesting;
+                const std::list< TypeDecl* > & typeParams;
+                OutputIterator out;
+                FuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) : container( container ), refType( refType ), functionNesting( functionNesting ), typeParams( typeParams ), out( out ) {}
+                /// generates a function (?{}, ?=?, ^?{}) based on the data argument and members. If function is generated, inserts the type into the map.
+                void gen( const FuncData & data, bool concurrent_type ) {
+                        if ( ! shouldGenerate( data.map, container ) ) return;
+                        FunctionType * ftype = data.genType( refType );
+                        if ( concurrent_type && CodeGen::isDestructor( data.fname ) ) {
+        Type * declToType( Declaration * decl ) {
+                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        return dwt->get_type();
+                }
+                return nullptr;
+        }
+        Type * declToTypeDeclBase( Declaration * decl ) {
+                if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) {
+                        return td->base;
+                }
+                return nullptr;
+        }
+        //=============================================================================================
+        // FuncGenerator member definitions
+        //=============================================================================================
+        void FuncGenerator::genStandardFuncs() {
+                std::list< FunctionDecl * > newFuncs;
+                generatePrototypes( newFuncs );
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        genFuncBody( dcl );
+                        if ( CodeGen::isAssignment( dcl->name ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->type;
+                                assert( assignType->parameters.size() == 2 );
+                                assert( assignType->returnVals.size() == 1 );
+                                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.front() );
+                                dcl->statements->push_back( new ReturnStmt( noLabels, new VariableExpr( dstParam ) ) );
+                        }
+                        resolve( dcl );
+                }
+        }
+        void FuncGenerator::generatePrototypes( std::list< FunctionDecl * > & newFuncs ) {
+                bool concurrent_type = isConcurrentType();
+                for ( const FuncData & d : data ) {
+                        // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
+                        FunctionType * ftype = d.genType( type );
+                        // destructor for concurrent type must be mutex
+                        if ( concurrent_type && CodeGen::isDestructor( d.fname ) ) {
                                 ftype->parameters.front()->get_type()->set_mutex( true );
+                        }
+                        cloneAll( typeParams, ftype->forall );
+                        *out++ = genFunc( data.fname, ftype, functionNesting );
+                        data.map.insert( Mangler::mangleType( refType ), true );
+                }
+        };
+        template< typename OutputIterator, typename Container >
+        FuncGenerator<OutputIterator, Container> makeFuncGenerator( const Container & container, Type *refType, unsigned int functionNesting, const std::list< TypeDecl* > & typeParams, OutputIterator out ) {
+                return FuncGenerator<OutputIterator, Container>( container, refType, functionNesting, typeParams, out );
+        }
+        /// generates a single enumeration assignment expression
+        ApplicationExpr * genEnumAssign( FunctionType * ftype, FunctionDecl * assignDecl ) {
+                // enum copy construct and assignment is just C-style assignment.
+                // this looks like a bad recursive call, but code gen will turn it into
+                // a C-style assignment.
+                // This happens before function pointer type conversion, so need to do it manually here
+                // NOTE: ftype is not necessarily the functionType belonging to assignDecl - ftype is the
+                // type of the function that this expression is being generated for (so that the correct
+                // parameters) are using in the variable exprs
+                assert( ftype->get_parameters().size() == 2 );
+                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
+                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
+                VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
+                Type * assignVarExprType = assignVarExpr->get_result();
+                assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
+                assignVarExpr->set_result( assignVarExprType );
+                ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
+                assignExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                assignExpr->get_args().push_back( new VariableExpr( srcParam ) );
+                return assignExpr;
+        }
+        // E ?=?(E volatile*, int),
+        //   ?=?(E _Atomic volatile*, int);
+        void makeEnumFunctions( EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
+                // T ?=?(E *, E);
+                FunctionType *assignType = genAssignType( refType );
+                // void ?{}(E *); void ^?{}(E *);
+                FunctionType * ctorType = genDefaultType( refType->clone() );
+                FunctionType * dtorType = genDefaultType( refType->clone() );
+                // void ?{}(E *, E);
+                FunctionType *copyCtorType = genCopyType( refType->clone() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
+                // right now these cases work, but that might change.
+                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
+                // Really they're something of a cross between instrinsic and autogen, so should
+                // probably make a new linkage type
+                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting, true );
+                FunctionDecl *ctorDecl = genFunc( "?{}", ctorType, functionNesting, true );
+                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting, true );
+                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting, true );
+                // body is either return stmt or expr stmt
+                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, genEnumAssign( assignType, assignDecl ) ) );
+                copyCtorDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, genEnumAssign( copyCtorType, assignDecl ) ) );
+                declsToAdd.push_back( ctorDecl );
+                declsToAdd.push_back( copyCtorDecl );
+                declsToAdd.push_back( dtorDecl );
+                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+        }
+        /// generates a single struct member operation (constructor call, destructor call, assignment call)
+        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ) {
+                        newFuncs.push_back( genFunc( d.fname, ftype, functionNesting ) );
+                }
+        }
+        void FuncGenerator::resolve( FunctionDecl * dcl ) {
+                try {
+                        ResolvExpr::resolveDecl( dcl, indexer );
+                        if ( functionNesting == 0 ) {
+                                // forward declare if top-level struct, so that
+                                // type is complete as soon as its body ends
+                                // Note: this is necessary if we want structs which contain
+                                // generic (otype) structs as members.
+                                addForwardDecl( dcl, forwards );
+                        }
+                        definitions.push_back( dcl );
+                        indexer.addId( dcl );
+                } catch ( SemanticError err ) {
+                        // okay if decl does not resolve - that means the function should not be generated
+                        delete dcl;
+                }
+        }
+        bool StructFuncGenerator::shouldAutogen() const {
+                // Builtins do not use autogeneration.
+                return ! aggregateDecl->linkage.is_builtin;
+        }
+        bool StructFuncGenerator::isConcurrentType() const { return aggregateDecl->is_thread() || aggregateDecl->is_monitor(); }
+        void StructFuncGenerator::genFuncBody( FunctionDecl * dcl ) {
+                // generate appropriate calls to member ctor, assignment
+                // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                if ( ! CodeGen::isDestructor( dcl->name ) ) {
+                        makeFunctionBody( aggregateDecl->members.begin(), aggregateDecl->members.end(), dcl );
+                } else {
+                        makeFunctionBody( aggregateDecl->members.rbegin(), aggregateDecl->members.rend(), dcl, false );
+                }
+        }
+        void StructFuncGenerator::genFieldCtors() {
+                // field ctors are only generated if default constructor and copy constructor are both generated
+                unsigned numCtors = std::count_if( definitions.begin(), definitions.end(), [](Declaration * dcl) { return CodeGen::isConstructor( dcl->name ); } );
+                // Field constructors are only generated if default and copy constructor
+                // are generated, since they need access to both
+                if ( numCtors != 2 ) return;
+                // create constructors which take each member type as a parameter.
+                // for example, for struct A { int x, y; }; generate
+                //   void ?{}(A *, int) and void ?{}(A *, int, int)
+                FunctionType * memCtorType = genDefaultType( type );
+                for ( Declaration * member : aggregateDecl->members ) {
+                        DeclarationWithType * field = strict_dynamic_cast<DeclarationWithType *>( member );
+                        if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( field ) ) ) {
+                                // don't make a function whose parameter is an unnamed bitfield
+                                continue;
+                        }
+                        memCtorType->parameters.push_back( new ObjectDecl( field->name, Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 ) );
+                        FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
+                        makeFieldCtorBody( aggregateDecl->members.begin(), aggregateDecl->members.end(), ctor );
+                        resolve( ctor );
+                }
+                delete memCtorType;
+        }
+        void StructFuncGenerator::makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward ) {
                 InitTweak::InitExpander srcParam( src );
                 // assign to destination
+                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
+                genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
+        }
+        /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
+                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->base->clone() ) );
+                genImplicitCall( srcParam, dstselect, func->name, back_inserter( func->statements->kids ), field, forward );
+        }
         template<typename Iterator>
         void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ) {
+        void StructFuncGenerator::makeFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward ) {
                 for ( ; member != end; ++member ) {
                         if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate
 …
+                                }
                                 if ( type->get_const() && func->get_name() == "?=?" ) {
+                                if ( type->get_const() && CodeGen::isAssignment( func->name ) ) {
                                         // don't assign const members, but do construct/destruct
                                         continue;
+                                }
-                                if ( field->get_name() == "" ) {
-                                        // don't assign to anonymous members
-                                        // xxx - this is a temporary fix. Anonymous members tie into
-                                        // our inheritance model. I think the correct way to handle this is to
-                                        // cast the structure to the type of the member and let the resolver
-                                        // figure out whether it's valid and have a pass afterwards that fixes
-                                        // the assignment to use pointer arithmetic with the offset of the
-                                        // member, much like how generic type members are handled.
-                                        continue;
+                                }
                                 assert( ! func->get_functionType()->get_parameters().empty() );
                                 ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
                                 ObjectDecl * srcParam = NULL;
+                                ObjectDecl * srcParam = nullptr;
                                 if ( func->get_functionType()->get_parameters().size() == 2 ) {
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
+                                }
                                 // srcParam may be NULL, in which case we have default ctor/dtor
                                 assert( dstParam );
                                 Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
+                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
+                                makeMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
                 } // for
+        } // makeStructFunctionBody
+        /// generate the body of a constructor which takes parameters that match fields, e.g.
+        /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+        } // makeFunctionBody
         template<typename Iterator>
         void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) {
                 FunctionType * ftype = func->get_functionType();
                 std::list<DeclarationWithType*> & params = ftype->get_parameters();
+        void StructFuncGenerator::makeFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) {
+                FunctionType * ftype = func->type;
+                std::list<DeclarationWithType*> & params = ftype->parameters;
                 assert( params.size() >= 2 );  // should not call this function for default ctor, etc.
 …
                                         // don't make a function whose parameter is an unnamed bitfield
                                         continue;
-                                } else if ( field->get_name() == "" ) {
-                                        // don't assign to anonymous members
-                                        // xxx - this is a temporary fix. Anonymous members tie into
-                                        // our inheritance model. I think the correct way to handle this is to
-                                        // cast the structure to the type of the member and let the resolver
-                                        // figure out whether it's valid and have a pass afterwards that fixes
-                                        // the assignment to use pointer arithmetic with the offset of the
-                                        // member, much like how generic type members are handled.
-                                        continue;
                                 } else if ( parameter != params.end() ) {
                                         // matching parameter, initialize field with copy ctor
                                         Expression *srcselect = new VariableExpr(*parameter);
                                         makeStructMemberOp( dstParam, srcselect, field, func );
+                                        makeMemberOp( dstParam, srcselect, field, func );
                                         ++parameter;
                                 } else {
                                         // no matching parameter, initialize field with default ctor
                                         makeStructMemberOp( dstParam, NULL, field, func );
+                                        makeMemberOp( dstParam, nullptr, field, func );
+                                }
+                        }
 …
+        }
+        Type * declToType( Declaration * decl ) {
+                if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                        return dwt->get_type();
+                }
+                return nullptr;
+        }
+        /// generates struct constructors, destructor, and assignment functions
+        void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
+        bool UnionFuncGenerator::shouldAutogen() const {
                 // Builtins do not use autogeneration.
+                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+                        return;
+                }
+                // Make function polymorphic in same parameters as generic struct, if applicable
+                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                // generate each of the functions based on the supplied FuncData objects
+                std::list< FunctionDecl * > newFuncs;
+                // structure that iterates aggregate decl members, returning their types
+                auto generator = makeFuncGenerator( lazy_map( aggregateDecl->members, declToType ), refType, functionNesting, typeParams, back_inserter( newFuncs ) );
+                for ( const FuncData & d : data ) {
+                        generator.gen( d, aggregateDecl->is_thread() || aggregateDecl->is_monitor() );
+                }
+                return ! aggregateDecl->linkage.is_builtin;
+        }
+        // xxx - is this right?
+        bool UnionFuncGenerator::isConcurrentType() const { return false; };
+        /// generate a single union assignment expression (using memcpy)
+        template< typename OutputIterator >
+        void UnionFuncGenerator::makeMemberOp( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
+                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
+                copy->args.push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
+                copy->args.push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
+                copy->args.push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
+                *out++ = new ExprStmt( noLabels, copy );
+        }
+        /// generates the body of a union assignment/copy constructor/field constructor
+        void UnionFuncGenerator::genFuncBody( FunctionDecl * funcDecl ) {
+                FunctionType * ftype = funcDecl->type;
+                if ( InitTweak::isCopyConstructor( funcDecl ) || InitTweak::isAssignment( funcDecl ) ) {
+                        assert( ftype->parameters.size() == 2 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.back() );
+                        makeMemberOp( srcParam, dstParam, back_inserter( funcDecl->statements->kids ) );
+                } else {
+                        // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
+                        assert( ftype->parameters.size() == 1 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        dstParam->attributes.push_back( new Attribute( "unused" ) );
+                }
+        }
+        /// generate the body of a constructor which takes parameters that match fields, e.g.
+        /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
+        void UnionFuncGenerator::genFieldCtors() {
                 // field ctors are only generated if default constructor and copy constructor are both generated
+                unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } );
+                if ( functionNesting == 0 ) {
+                        // forward declare if top-level struct, so that
+                        // type is complete as soon as its body ends
+                        // Note: this is necessary if we want structs which contain
+                        // generic (otype) structs as members.
+                        for ( FunctionDecl * dcl : newFuncs ) {
+                                addForwardDecl( dcl, declsToAdd );
+                        }
+                }
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        // generate appropriate calls to member ctor, assignment
+                        // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                        if ( ! CodeGen::isDestructor( dcl->get_name() ) ) {
+                                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl );
+                        } else {
+                                makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, false );
+                        }
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->get_functionType();
+                                assert( assignType->get_parameters().size() == 2 );
+                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
+                                dcl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                        }
+                        declsToAdd.push_back( dcl );
+                }
+                // create constructors which take each member type as a parameter.
+                // for example, for struct A { int x, y; }; generate
+                //   void ?{}(A *, int) and void ?{}(A *, int, int)
+                unsigned numCtors = std::count_if( definitions.begin(), definitions.end(), [](Declaration * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } );
                 // Field constructors are only generated if default and copy constructor
                 // are generated, since they need access to both
+                if ( numCtors == 2 ) {
+                        FunctionType * memCtorType = genDefaultType( refType );
+                        cloneAll( typeParams, memCtorType->get_forall() );
+                        for ( std::list<Declaration *>::iterator i = aggregateDecl->get_members().begin(); i != aggregateDecl->get_members().end(); ++i ) {
+                                DeclarationWithType * member = dynamic_cast<DeclarationWithType *>( *i );
+                                assert( member );
+                                if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( member ) ) ) {
+                                        // don't make a function whose parameter is an unnamed bitfield
+                                        continue;
+                                } else if ( member->get_name() == "" ) {
+                                        // don't assign to anonymous members
+                                        // xxx - this is a temporary fix. Anonymous members tie into
+                                        // our inheritance model. I think the correct way to handle this is to
+                                        // cast the structure to the type of the member and let the resolver
+                                        // figure out whether it's valid/choose the correct unnamed member
+                                        continue;
+                                }
+                                memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
+                                FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
+                                makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor );
+                                declsToAdd.push_back( ctor );
+                        }
+                        delete memCtorType;
+                }
+        }
+        /// generate a single union assignment expression (using memcpy)
+        template< typename OutputIterator >
+        void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
+                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
+                copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
+                *out++ = new ExprStmt( noLabels, copy );
+        }
+        /// generates the body of a union assignment/copy constructor/field constructor
+        void makeUnionAssignBody( FunctionDecl * funcDecl ) {
+                FunctionType * ftype = funcDecl->get_functionType();
+                assert( ftype->get_parameters().size() == 2 );
+                ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
+                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
+                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
+                if ( CodeGen::isAssignment( funcDecl->get_name() ) ) {
+                        // also generate return statement in assignment
+                        funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                }
+        }
+        /// generates union constructors, destructors, and assignment operator
+        void makeUnionFunctions( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd ) {
+                // Make function polymorphic in same parameters as generic union, if applicable
+                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                // default ctor/dtor need only first parameter
+                // void ?{}(T *); void ^?{}(T *);
+                FunctionType *ctorType = genDefaultType( refType );
+                FunctionType *dtorType = genDefaultType( refType );
+                // copy ctor needs both parameters
+                // void ?{}(T *, T);
+                FunctionType *copyCtorType = genCopyType( refType );
+                // assignment needs both and return value
+                // T ?=?(T *, T);
+                FunctionType *assignType = genAssignType( refType );
+                cloneAll( typeParams, ctorType->get_forall() );
+                cloneAll( typeParams, dtorType->get_forall() );
+                cloneAll( typeParams, copyCtorType->get_forall() );
+                cloneAll( typeParams, assignType->get_forall() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
+                // because each unit generates copies of the default routines for each aggregate.
+                FunctionDecl *assignDecl = genFunc( "?=?", assignType, functionNesting );
+                FunctionDecl *ctorDecl = genFunc( "?{}",  ctorType, functionNesting );
+                FunctionDecl *copyCtorDecl = genFunc( "?{}", copyCtorType, functionNesting );
+                FunctionDecl *dtorDecl = genFunc( "^?{}", dtorType, functionNesting );
+                makeUnionAssignBody( assignDecl );
+                // body of assignment and copy ctor is the same
+                makeUnionAssignBody( copyCtorDecl );
+                if ( numCtors != 2 ) return;
                 // create a constructor which takes the first member type as a parameter.
 …
                 // void ?{}(A *, int)
                 // This is to mimic C's behaviour which initializes the first member of the union.
+                std::list<Declaration *> memCtors;
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
+                                ObjectDecl * srcParam = new ObjectDecl( "src", Type::StorageClasses(), LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
+                                FunctionType * memCtorType = ctorType->clone();
+                                memCtorType->get_parameters().push_back( srcParam );
+                                FunctionDecl * ctor = genFunc( "?{}", memCtorType, functionNesting );
+                                makeUnionAssignBody( ctor );
+                                memCtors.push_back( ctor );
+                                // only generate a ctor for the first field
+                FunctionType * memCtorType = genDefaultType( type );
+                for ( Declaration * member : aggregateDecl->members ) {
+                        DeclarationWithType * field = strict_dynamic_cast<DeclarationWithType *>( member );
+                        if ( isUnnamedBitfield( dynamic_cast< ObjectDecl * > ( field ) ) ) {
+                                // don't make a function whose parameter is an unnamed bitfield
                                 break;
+                        }
+                }
+                declsToAdd.push_back( ctorDecl );
+                declsToAdd.push_back( copyCtorDecl );
+                declsToAdd.push_back( dtorDecl );
+                declsToAdd.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+                declsToAdd.splice( declsToAdd.end(), memCtors );
+        }
+                        memCtorType->parameters.push_back( new ObjectDecl( field->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, field->get_type()->clone(), nullptr ) );
+                        FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
+                        ObjectDecl * srcParam = strict_dynamic_cast<ObjectDecl *>( ctor->type->parameters.back() );
+                        srcParam->fixUniqueId();
+                        ObjectDecl * dstParam = InitTweak::getParamThis( ctor->type );
+                        makeMemberOp( srcParam, dstParam, back_inserter( ctor->statements->kids ) );
+                        resolve( ctor );
+                        // only generate one field ctor for unions
+                        break;
+                }
+                delete memCtorType;
+        }
+        void EnumFuncGenerator::genFuncBody( FunctionDecl * funcDecl ) {
+                // xxx - Temporary: make these functions intrinsic so they codegen as C assignment.
+                // Really they're something of a cross between instrinsic and autogen, so should
+                // probably make a new linkage type
+                funcDecl->linkage = LinkageSpec::Intrinsic;
+                FunctionType * ftype = funcDecl->type;
+                if ( InitTweak::isCopyConstructor( funcDecl ) || InitTweak::isAssignment( funcDecl ) ) {
+                        assert( ftype->parameters.size() == 2 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.back() );
+                        // enum copy construct and assignment is just C-style assignment.
+                        // this looks like a bad recursive call, but code gen will turn it into
+                        // a C-style assignment.
+                        // This happens before function pointer type conversion, so need to do it manually here
+                        ApplicationExpr * callExpr = new ApplicationExpr( VariableExpr::functionPointer( funcDecl ) );
+                        callExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                        callExpr->get_args().push_back( new VariableExpr( srcParam ) );
+                        funcDecl->statements->push_back( new ExprStmt( noLabels, callExpr ) );
+                } else {
+                        // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
+                        assert( ftype->parameters.size() == 1 );
+                        ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->parameters.front() );
+                        dstParam->attributes.push_back( new Attribute( "unused" ) );
+                }
+        }
+        bool EnumFuncGenerator::shouldAutogen() const { return true; }
+        bool EnumFuncGenerator::isConcurrentType() const { return false; }
+        // enums do not have field constructors
+        void EnumFuncGenerator::genFieldCtors() {}
+        bool TypeFuncGenerator::shouldAutogen() const { return true; };
+        void TypeFuncGenerator::genFuncBody( FunctionDecl * dcl ) {
+                FunctionType * ftype = dcl->type;
+                assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() );
+                DeclarationWithType * dst = ftype->parameters.front();
+                DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr;
+                // generate appropriate calls to member ctor, assignment
+                UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) );
+                expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
+                if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
+                dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+        };
+        // xxx - should reach in and determine if base type is concurrent?
+        bool TypeFuncGenerator::isConcurrentType() const { return false; };
+        // opaque types do not have field constructors
+        void TypeFuncGenerator::genFieldCtors() {};
+        //=============================================================================================
+        // Visitor definitions
+        //=============================================================================================
         AutogenerateRoutines::AutogenerateRoutines() {
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
+                data.push_back( FuncData( "?{}", genDefaultType, constructable ) );
+                data.push_back( FuncData( "?{}", genCopyType, copyable ) );
+                data.push_back( FuncData( "^?{}", genDefaultType, destructable ) );
+                data.push_back( FuncData( "?=?", genAssignType, assignable ) );
+        }
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
+                if ( ! enumDecl->get_members().empty() ) {
+                        EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
+                        // enumInst->set_baseEnum( enumDecl );
+                        makeEnumFunctions( enumInst, functionNesting, declsToAddAfter );
+                }
+        }
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+                if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
+                        for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
+                                // need to visit assertions so that they are added to the appropriate maps
+                                acceptAll( typeDecl->get_assertions(), *this );
+                                structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+                        }
+                data.emplace_back( "?{}", genDefaultType );
+                data.emplace_back( "?{}", genCopyType );
+                data.emplace_back( "^?{}", genDefaultType );
+                data.emplace_back( "?=?", genAssignType );
+        }
+        void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
+                // must visit children (enum constants) to add them to the indexer
+                if ( enumDecl->has_body() ) {
+                        EnumInstType enumInst( Type::Qualifiers(), enumDecl->get_name() );
+                        enumInst.set_baseEnum( enumDecl );
+                        EnumFuncGenerator gen( &enumInst, data, functionNesting, indexer );
+                        generateFunctions( gen, declsToAddAfter );
+                }
+        }
+        void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
+                visit_children = false;
+                if ( structDecl->has_body() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->name );
                         structInst.set_baseStruct( structDecl );
+                        makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
+                        structsDone.insert( structDecl->get_name() );
+                        for ( TypeDecl * typeDecl : structDecl->parameters ) {
+                                structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
+                        }
+                        StructFuncGenerator gen( structDecl, &structInst, data, functionNesting, indexer );
+                        generateFunctions( gen, declsToAddAfter );
                 } // if
+        }
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+                if ( ! unionDecl->get_members().empty() ) {
+        void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
+                visit_children = false;
+                if ( unionDecl->has_body()  ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
                         unionInst.set_baseUnion( unionDecl );
 …
                                 unionInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+                        }
+                        makeUnionFunctions( unionDecl, &unionInst, functionNesting, declsToAddAfter );
+                        UnionFuncGenerator gen( unionDecl, &unionInst, data, functionNesting, indexer );
+                        generateFunctions( gen, declsToAddAfter );
                 } // if
+        }
-        Type * declToTypeDeclBase( Declaration * decl ) {
-                if ( TypeDecl * td = dynamic_cast< TypeDecl * >( decl ) ) {
-                        return td->base;
+                }
-                return nullptr;
+        }
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
+        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
+                visit_children = false;
                 if ( ! typeDecl->base ) return;
-                // generate each of the functions based on the supplied FuncData objects
-                std::list< FunctionDecl * > newFuncs;
-                std::list< Declaration * > tds { typeDecl };
-                std::list< TypeDecl * > typeParams;
                 TypeInstType refType( Type::Qualifiers(), typeDecl->name, typeDecl );
+                auto generator = makeFuncGenerator( lazy_map( tds, declToTypeDeclBase ), &refType, functionNesting, typeParams, back_inserter( newFuncs ) );
+                for ( const FuncData & d : data ) {
+                        generator.gen( d, false );
+                }
+                if ( functionNesting == 0 ) {
+                        // forward declare if top-level struct, so that
+                        // type is complete as soon as its body ends
+                        // Note: this is necessary if we want structs which contain
+                        // generic (otype) structs as members.
+                        for ( FunctionDecl * dcl : newFuncs ) {
+                                addForwardDecl( dcl, declsToAddAfter );
+                        }
+                }
+                for ( FunctionDecl * dcl : newFuncs ) {
+                        FunctionType * ftype = dcl->type;
+                        assertf( ftype->parameters.size() == 1 || ftype->parameters.size() == 2, "Incorrect number of parameters in autogenerated typedecl function: %zd", ftype->parameters.size() );
+                        DeclarationWithType * dst = ftype->parameters.front();
+                        DeclarationWithType * src = ftype->parameters.size() == 2 ? ftype->parameters.back() : nullptr;
+                        // generate appropriate calls to member ctor, assignment
+                        // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
+                        UntypedExpr * expr = new UntypedExpr( new NameExpr( dcl->name ) );
+                        expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
+                        if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
+                        dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
+                                // assignment needs to return a value
+                                FunctionType * assignType = dcl->type;
+                                assert( assignType->parameters.size() == 2 );
+                                ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.back() );
+                                dcl->statements->kids.push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                        }
+                        declsToAddAfter.push_back( dcl );
+                }
+        }
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                } // for
+                declsToAdd.clear();
+        }
+        void AutogenerateRoutines::visit( FunctionType *) {
+                TypeFuncGenerator gen( typeDecl, &refType, data, functionNesting, indexer );
+                generateFunctions( gen, declsToAddAfter );
+        }
+        void AutogenerateRoutines::previsit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
+        }
+        void AutogenerateRoutines::visit( PointerType *) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
+        }
+        void AutogenerateRoutines::visit( TraitDecl *) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( TraitDecl * ) {
                 // ensure that we don't add assignment ops for types defined as part of the trait
+        }
+        template< typename StmtClass >
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+        }
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+        }
+        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
+                visit_children = false;
                 // record the existence of this function as appropriate
+                insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
+                insert( functionDecl, assignable, InitTweak::isAssignment );
+                insert( functionDecl, copyable, InitTweak::isCopyConstructor );
+                insert( functionDecl, destructable, InitTweak::isDestructor );
+                maybeAccept( functionDecl->get_functionType(), *this );
+                managedTypes.handleDWT( functionDecl );
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
                 maybeAccept( functionDecl->get_statements(), *this );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
+        }
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+                constructable.beginScope();
+                assignable.beginScope();
+                copyable.beginScope();
+                destructable.beginScope();
+                visitStatement( compoundStmt );
+                constructable.endScope();
+                assignable.endScope();
+                copyable.endScope();
+                destructable.endScope();
+        }
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+                visitStatement( switchStmt );
+        void AutogenerateRoutines::previsit( CompoundStmt * ) {
+                GuardScope( managedTypes );
+                GuardScope( structsDone );
+        }
 …
+        }
+        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
+                tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
+        void AutogenTupleRoutines::postvisit( TupleType * tupleType ) {
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
                 if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
+                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return;
                 seenTuples.insert( mangleName );
 …
                         if ( TypeInstType * ty = dynamic_cast< TypeInstType * >( t ) ) {
                                 if ( ! done.count( ty->get_baseType() ) ) {
                                         TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Any );
+                                        TypeDecl * newDecl = new TypeDecl( ty->get_baseType()->get_name(), Type::StorageClasses(), nullptr, TypeDecl::Dtype, true );
                                         TypeInstType * inst = new TypeInstType( Type::Qualifiers(), newDecl->get_name(), newDecl );
                                         newDecl->get_assertions().push_back( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, genAssignType( inst ), nullptr,
 …
                 makeTupleFunctionBody( dtorDecl );
+                addDeclaration( ctorDecl );
+                addDeclaration( copyCtorDecl );
+                addDeclaration( dtorDecl );
+                addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return
+                return tupleType;
+        }
+        DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+                declsToAddBefore.push_back( ctorDecl );
+                declsToAddBefore.push_back( copyCtorDecl );
+                declsToAddBefore.push_back( dtorDecl );
+                declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
+        }
+        void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                maybeAccept( functionDecl->statements, *visitor );
                 functionNesting -= 1;
+                return functionDecl;
+        }
+        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
+                seenTuples.beginScope();
+                compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
+                seenTuples.endScope();
+                return compoundStmt;
+        }
+        void AutogenTupleRoutines::previsit( CompoundStmt * ) {
+                GuardScope( seenTuples );
+        }
 } // SymTab

src/SymTab/Autogen.h

-              r78315272
+              r3f7e12cb
 #include <string>                 // for string
+#include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
 #include "InitTweak/InitTweak.h"  // for InitExpander
 …
         extern FunctionDecl * dereferenceOperator;
         // temporary
+        // generate the type of an assignment function for paramType
         FunctionType * genAssignType( Type * paramType );
+        // generate the type of a default constructor or destructor for paramType
+        FunctionType * genDefaultType( Type * paramType );
+        // generate the type of a copy constructor for paramType
+        FunctionType * genCopyType( Type * paramType );
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
 …
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
+                bool isReferenceCtorDtor = false;
+                if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
+                        // reference constructors are essentially application of the rebind operator.
+                        // apply & to both arguments, do not need a cast
+                        fname = "?=?";
+                        dstParam = new AddressExpr( dstParam );
+                        addCast = false;
+                        isReferenceCtorDtor = true;
+                }
                 // want to be able to generate assignment, ctor, and dtor generically,
                 // so fname is either ?=?, ?{}, or ^?{}
                 UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+                UntypedExpr * fExpr = new UntypedExpr( new NameExpr( fname ) );
                 if ( addCast ) {
 …
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
+                }
                 fExpr->get_args().push_back( dstParam );
+                fExpr->args.push_back( dstParam );
                 Statement * listInit = srcParam.buildListInit( fExpr );
+                std::list< Expression * > args = *++srcParam;
+                fExpr->get_args().splice( fExpr->get_args().end(), args );
+                // fetch next set of arguments
+                ++srcParam;
+                // return if adding reference fails - will happen on default constructor and destructor
+                if ( isReferenceCtorDtor && ! srcParam.addReference() ) {
+                        delete fExpr;
+                        return listInit;
+                }
+                std::list< Expression * > args = *srcParam;
+                fExpr->args.splice( fExpr->args.end(), args );
                 *out++ = new ExprStmt( noLabels, fExpr );
 …
                         // generate: for ( int i = 0; i < N; ++i )
                         begin = new ConstantExpr( Constant::from_int( 0 ) );
                         end = array->get_dimension()->clone();
+                        end = array->dimension->clone();
                         cmp = new NameExpr( "?<?" );
                         update = new NameExpr( "++?" );
 …
                         // generate: for ( int i = N-1; i >= 0; --i )
                         begin = new UntypedExpr( new NameExpr( "?-?" ) );
                         ((UntypedExpr*)begin)->get_args().push_back( array->get_dimension()->clone() );
                         ((UntypedExpr*)begin)->get_args().push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
+                        ((UntypedExpr*)begin)->args.push_back( array->dimension->clone() );
+                        ((UntypedExpr*)begin)->args.push_back( new ConstantExpr( Constant::from_int( 1 ) ) );
                         end = new ConstantExpr( Constant::from_int( 0 ) );
                         cmp = new NameExpr( "?>=?" );
 …
                 UntypedExpr *cond = new UntypedExpr( cmp );
                 cond->get_args().push_back( new VariableExpr( index ) );
                 cond->get_args().push_back( end );
+                cond->args.push_back( new VariableExpr( index ) );
+                cond->args.push_back( end );
                 UntypedExpr *inc = new UntypedExpr( update );
                 inc->get_args().push_back( new VariableExpr( index ) );
+                inc->args.push_back( new VariableExpr( index ) );
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
                 dstIndex->get_args().push_back( dstParam );
                 dstIndex->get_args().push_back( new VariableExpr( index ) );
+                dstIndex->args.push_back( dstParam );
+                dstIndex->args.push_back( new VariableExpr( index ) );
                 dstParam = dstIndex;
                 // srcParam must keep track of the array indices to build the
                 // source parameter and/or array list initializer
                 srcParam.addArrayIndex( new VariableExpr( index ), array->get_dimension()->clone() );
+                srcParam.addArrayIndex( new VariableExpr( index ), array->dimension->clone() );
                 // for stmt's body, eventually containing call
                 CompoundStmt * body = new CompoundStmt( noLabels );
                 Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->get_kids() ), array->get_base(), addCast, forward );
+                Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
                 // block containing for stmt and index variable
                 std::list<Statement *> initList;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 block->get_kids().push_back( new DeclStmt( noLabels, index ) );
+                block->push_back( new DeclStmt( noLabels, index ) );
                 if ( listInit ) block->get_kids().push_back( listInit );
                 block->get_kids().push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+                block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
                 *out++ = block;
 …
         template< typename OutputIterator >
         Statement * genCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
 …
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
         void genImplicitCall( InitTweak::InitExpander &  srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );
 …
                 bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
                 std::list< Statement * > stmts;
                 genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->get_type(), addCast, forward );
+                genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );
                 // currently genCall should produce at most one element, but if that changes then the next line needs to be updated to grab the statement which contains the call

src/SymTab/FixFunction.cc

-              r78315272
+              r3f7e12cb
         FixFunction::FixFunction() : isVoid( false ) {}
+        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
+                functionDecl->get_attributes().clear();
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
+        DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
+                // can't delete function type because it may contain assertions, so transfer ownership to new object
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
+                functionDecl->attributes.clear();
+                functionDecl->type = nullptr;
                 delete functionDecl;
                 return pointer;
+        }
+        Type * FixFunction::mutate(VoidType *voidType) {
+                isVoid = true;
+                return voidType;
+        }
+        Type * FixFunction::mutate(BasicType *basicType) {
+                return basicType;
+        }
+        Type * FixFunction::mutate(PointerType *pointerType) {
+                return pointerType;
+        }
+        Type * FixFunction::mutate(ArrayType *arrayType) {
+        Type * FixFunction::postmutate(ArrayType *arrayType) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
+                arrayType->base = nullptr;
+                arrayType->dimension = nullptr;
                 delete arrayType;
                 return pointerType;
+        }
         Type * FixFunction::mutate(StructInstType *aggregateUseType) {
                 return aggregateUseType;
+        void FixFunction::premutate(VoidType *) {
+                isVoid = true;
+        }
+        Type * FixFunction::mutate(UnionInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(EnumInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(TraitInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(TypeInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+        Type * FixFunction::mutate(TupleType *tupleType) {
+                return tupleType;
+        }
+        Type * FixFunction::mutate(VarArgsType *varArgsType) {
+                return varArgsType;
+        }
+        Type * FixFunction::mutate(ZeroType *zeroType) {
+                return zeroType;
+        }
+        Type * FixFunction::mutate(OneType *oneType) {
+                return oneType;
+        }
+        void FixFunction::premutate(FunctionDecl *) { visit_children = false; }
+        void FixFunction::premutate(ArrayType *) { visit_children = false; }
+        void FixFunction::premutate(BasicType *) { visit_children = false; }
+        void FixFunction::premutate(PointerType *) { visit_children = false; }
+        void FixFunction::premutate(StructInstType *) { visit_children = false; }
+        void FixFunction::premutate(UnionInstType *) { visit_children = false; }
+        void FixFunction::premutate(EnumInstType *) { visit_children = false; }
+        void FixFunction::premutate(TraitInstType *) { visit_children = false; }
+        void FixFunction::premutate(TypeInstType *) { visit_children = false; }
+        void FixFunction::premutate(TupleType *) { visit_children = false; }
+        void FixFunction::premutate(VarArgsType *) { visit_children = false; }
+        void FixFunction::premutate(ZeroType *) { visit_children = false; }
+        void FixFunction::premutate(OneType *) { visit_children = false; }
 } // namespace SymTab

src/SymTab/FixFunction.h

-              r78315272
+              r3f7e12cb
 #pragma once
 #include "SynTree/Mutator.h"  // for Mutator
 #include "SynTree/SynTree.h"  // for Types
+#include "Common/PassVisitor.h" // for PassVisitor
+#include "SynTree/SynTree.h"    // for Types
 namespace SymTab {
         /// Replaces function and array types by equivalent pointer types.
         class FixFunction : public Mutator {
+        class FixFunction : public WithShortCircuiting {
                 typedef Mutator Parent;
           public:
                 FixFunction();
+                bool get_isVoid() const { return isVoid; }
+                void set_isVoid( bool newValue ) { isVoid = newValue; }
+          private:
+                virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
+                void premutate(FunctionDecl *functionDecl);
+                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
+                virtual Type* mutate(VoidType *voidType);
+                virtual Type* mutate(BasicType *basicType);
+                virtual Type* mutate(PointerType *pointerType);
+                virtual Type* mutate(ArrayType *arrayType);
+                virtual Type* mutate(StructInstType *aggregateUseType);
+                virtual Type* mutate(UnionInstType *aggregateUseType);
+                virtual Type* mutate(EnumInstType *aggregateUseType);
+                virtual Type* mutate(TraitInstType *aggregateUseType);
+                virtual Type* mutate(TypeInstType *aggregateUseType);
+                virtual Type* mutate(TupleType *tupleType);
+                virtual Type* mutate(VarArgsType *varArgsType);
+                virtual Type* mutate(ZeroType *zeroType);
+                virtual Type* mutate(OneType *oneType);
+                Type * postmutate(ArrayType * arrayType);
+                void premutate(ArrayType * arrayType);
+                void premutate(VoidType * voidType);
+                void premutate(BasicType * basicType);
+                void premutate(PointerType * pointerType);
+                void premutate(StructInstType * aggregateUseType);
+                void premutate(UnionInstType * aggregateUseType);
+                void premutate(EnumInstType * aggregateUseType);
+                void premutate(TraitInstType * aggregateUseType);
+                void premutate(TypeInstType * aggregateUseType);
+                void premutate(TupleType * tupleType);
+                void premutate(VarArgsType * varArgsType);
+                void premutate(ZeroType * zeroType);
+                void premutate(OneType * oneType);
                 bool isVoid;

src/SymTab/Indexer.cc

-              r78315272
+              r3f7e12cb
 namespace SymTab {
-        struct NewScope {
-                NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
-                ~NewScope() { indexer.leaveScope(); }
-                SymTab::Indexer & indexer;
-        };
-        template< typename TreeType, typename VisitorType >
-        inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
-                visitor.enterScope();
-                maybeAccept( tree, visitor );
-                visitor.leaveScope();
+        }
         typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
         typedef std::unordered_map< std::string, MangleTable > IdTable;
 …
+        }
         Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
         Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
         Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
+        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
+        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
+        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
                 that.tables = 0;
+        }
 …
                 makeWritable();
                 const std::string &name = decl->get_name();
+                const std::string &name = decl->name;
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
+                if ( LinkageSpec::isOverridable( decl->linkage ) ) {
                         // mangle the name without including the appropriate suffix, so overridable routines are placed into the
                         // same "bucket" as their user defined versions.
 …
                 // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
                 if ( ! LinkageSpec::isMangled( decl->get_linkage() ) ) {
+                if ( ! LinkageSpec::isMangled( decl->linkage ) ) {
                         // NOTE this is broken in Richard's original code in such a way that it never triggers (it
                         // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
 …
                 if ( doDebug ) {
                         std::cout << "--- Entering scope " << scope << std::endl;
+                        std::cerr << "--- Entering scope " << scope << std::endl;
+                }
+        }
         void Indexer::leaveScope() {
                 using std::cout;
+                using std::cerr;
                 assert( scope > 0 && "cannot leave initial scope" );
+                if ( doDebug ) {
+                        cerr << "--- Leaving scope " << scope << " containing" << std::endl;
+                }
                 --scope;
                 while ( tables && tables->scope > scope ) {
                         if ( doDebug ) {
+                                cout << "--- Leaving scope " << tables->scope << " containing" << std::endl;
+                                dump( tables->idTable, cout );
+                                dump( tables->typeTable, cout );
+                                dump( tables->structTable, cout );
+                                dump( tables->enumTable, cout );
+                                dump( tables->unionTable, cout );
+                                dump( tables->traitTable, cout );
+                                dump( tables->idTable, cerr );
+                                dump( tables->typeTable, cerr );
+                                dump( tables->structTable, cerr );
+                                dump( tables->enumTable, cerr );
+                                dump( tables->unionTable, cerr );
+                                dump( tables->traitTable, cerr );
+                        }

src/SymTab/Indexer.h

-              r78315272
+              r3f7e12cb
         class Indexer {
           public:
                 explicit Indexer( bool useDebug = false );
+                explicit Indexer();
                 Indexer( const Indexer &that );
 …
                 void addTrait( TraitDecl *decl );
+                bool doDebug = false; ///< Display debugging trace?
           private:
                 struct Impl;
 …
                 Impl *tables;         ///< Copy-on-write instance of table data structure
                 unsigned long scope;  ///< Scope index of this pointer
-                bool doDebug;         ///< Display debugging trace?
                 /// Takes a new ref to a table (returns null if null)

src/SymTab/Mangler.cc

-              r78315272
+              r3f7e12cb
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jun 28 15:31:00 2017
 // Update Count     : 21
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 25 15:49:26 2017
+// Update Count     : 23
 //
 #include "Mangler.h"
 …
 namespace SymTab {
         std::string Mangler::mangleType( Type *ty ) {
                 Mangler mangler( false, true );
+        std::string Mangler::mangleType( Type * ty ) {
+                Mangler mangler( false, true, true );
                 maybeAccept( ty, mangler );
                 return mangler.get_mangleName();
+        }
+        Mangler::Mangler( bool mangleOverridable, bool typeMode )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
+        std::string Mangler::mangleConcrete( Type* ty ) {
+                Mangler mangler( false, false, false );
+                maybeAccept( ty, mangler );
+                return mangler.get_mangleName();
+        }
+        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
 …
+        }
         void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
                 bool wasTopLevel = isTopLevel;
                 if ( isTopLevel ) {
 …
+        }
         void Mangler::visit( ObjectDecl *declaration ) {
+        void Mangler::visit( ObjectDecl * declaration ) {
                 mangleDecl( declaration );
+        }
         void Mangler::visit( FunctionDecl *declaration ) {
+        void Mangler::visit( FunctionDecl * declaration ) {
                 mangleDecl( declaration );
+        }
         void Mangler::visit( VoidType *voidType ) {
+        void Mangler::visit( VoidType * voidType ) {
                 printQualifiers( voidType );
                 mangleName << "v";
+        }
         void Mangler::visit( BasicType *basicType ) {
+        void Mangler::visit( BasicType * basicType ) {
                 static const char *btLetter[] = {
                         "b",    // Bool
 …
                         "Id",   // DoubleImaginary
                         "Ir",   // LongDoubleImaginary
+                        "w",    // SignedInt128
+                        "Uw",   // UnsignedInt128
                 };
 …
+        }
         void Mangler::visit( PointerType *pointerType ) {
+        void Mangler::visit( PointerType * pointerType ) {
                 printQualifiers( pointerType );
                 mangleName << "P";
 …
+        }
         void Mangler::visit( ArrayType *arrayType ) {
+        void Mangler::visit( ArrayType * arrayType ) {
                 // TODO: encode dimension
                 printQualifiers( arrayType );
 …
+        }
         void Mangler::visit( ReferenceType *refType ) {
+        void Mangler::visit( ReferenceType * refType ) {
                 printQualifiers( refType );
                 mangleName << "R";
 …
+        }
         void Mangler::visit( FunctionType *functionType ) {
+        void Mangler::visit( FunctionType * functionType ) {
                 printQualifiers( functionType );
                 mangleName << "F";
 …
+        }
         void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
                 printQualifiers( refType );
                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+        }
+        void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
+                printQualifiers( refType );
+                std::ostringstream oldName( mangleName.str() );
+                mangleName.clear();
+                mangleName << prefix << refType->get_name();
+                std::list< Expression* >& params = refType->get_parameters();
+                if ( ! params.empty() ) {
+                        mangleName << "_";
+                        for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
+                                maybeAccept( paramType->get_type(), *this );
+                if ( mangleGenericParams ) {
+                        std::list< Expression* >& params = refType->get_parameters();
+                        if ( ! params.empty() ) {
+                                mangleName << "_";
+                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
+                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
+                                        maybeAccept( paramType->get_type(), *this );
+                                }
+                                mangleName << "_";
+                        }
-                        mangleName << "_";
+                }
+                oldName << mangleName.str().length() << mangleName.str();
+                mangleName.str( oldName.str() );
+        }
+        void Mangler::visit( StructInstType *aggregateUseType ) {
+                if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
+                else mangleRef( aggregateUseType, "s" );
+        }
+        void Mangler::visit( UnionInstType *aggregateUseType ) {
+                if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
+                else mangleRef( aggregateUseType, "u" );
+        }
+        void Mangler::visit( EnumInstType *aggregateUseType ) {
+        }
+        void Mangler::visit( StructInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "s" );
+        }
+        void Mangler::visit( UnionInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "u" );
+        }
+        void Mangler::visit( EnumInstType * aggregateUseType ) {
                 mangleRef( aggregateUseType, "e" );
+        }
         void Mangler::visit( TypeInstType *typeInst ) {
+        void Mangler::visit( TypeInstType * typeInst ) {
                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                 if ( varNum == varNums.end() ) {
 …
                         numStream << varNum->second.first;
                         switch ( (TypeDecl::Kind )varNum->second.second ) {
-                          case TypeDecl::Any:
-                                mangleName << "t";
-                                break;
                           case TypeDecl::Dtype:
                                 mangleName << "d";
 …
+        }
         void Mangler::visit( TupleType *tupleType ) {
+        void Mangler::visit( TupleType * tupleType ) {
                 printQualifiers( tupleType );
                 mangleName << "T";
                 acceptAll( tupleType->get_types(), *this );
+                acceptAll( tupleType->types, *this );
                 mangleName << "_";
+        }
         void Mangler::visit( VarArgsType *varArgsType ) {
+        void Mangler::visit( VarArgsType * varArgsType ) {
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
+        }
         void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Mangler::visit( ZeroType * ) {
                 mangleName << "Z";
+        }
         void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
+        void Mangler::visit( OneType * ) {
                 mangleName << "O";
+        }
         void Mangler::visit( TypeDecl *decl ) {
+        void Mangler::visit( TypeDecl * decl ) {
                 static const char *typePrefix[] = { "BT", "BD", "BF" };
                 mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+        }
 …
+        }
         void Mangler::printQualifiers( Type *type ) {
+        void Mangler::printQualifiers( Type * type ) {
                 // skip if not including qualifiers
                 if ( typeMode ) return;
 …
                         int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
-                                  case TypeDecl::Any:
-                                        tcount++;
-                                        break;
                                   case TypeDecl::Dtype:
                                         dcount++;
 …
                                         assert( false );
                                 } // switch
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
                                         Mangler sub_mangler( mangleOverridable, typeMode );
+                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
+                                        Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
                                         sub_mangler.nextVarNum = nextVarNum;
                                         sub_mangler.isTopLevel = false;
 …
                         mangleName << "V";
                 } // if
+                if ( type->get_mutex() ) {
+                        mangleName << "M";
+                } // if
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {
 …
 //              } // if
                 if ( type->get_lvalue() ) {
+                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                         mangleName << "L";
                 } // if
+                }
                 if ( type->get_atomic() ) {
                         mangleName << "A";

src/SymTab/Mangler.h

-              r78315272
+              r3f7e12cb
                 /// Mangle syntax tree object; primary interface to clients
                 template< typename SynTreeClass >
             static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false );
+            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
                 /// Mangle a type name; secondary interface
                 static std::string mangleType( Type* ty );
+                /// Mangle ignoring generic type parameters
+                static std::string mangleConcrete( Type* ty );
                 virtual void visit( ObjectDecl *declaration );
 …
                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
                 bool typeMode;                  ///< Produce a unique mangled name for a type
+                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
                 Mangler( bool mangleOverridable, bool typeMode );
+                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
                 Mangler( const Mangler & );
                 void mangleDecl( DeclarationWithType *declaration );
                 void mangleRef( ReferenceToType *refType, std::string prefix );
-                void mangleGenericRef( ReferenceToType *refType, std::string prefix );
                 void printQualifiers( Type *type );
 …
         template< typename SynTreeClass >
         std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode ) {
                 Mangler mangler( mangleOverridable, typeMode );
+        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
+                Mangler mangler( mangleOverridable, typeMode, mangleGenericParams );
                 maybeAccept( decl, mangler );
                 return mangler.get_mangleName();

src/SymTab/Validate.cc

-              r78315272
+              r3f7e12cb
 #include "FixFunction.h"               // for FixFunction
 #include "Indexer.h"                   // for Indexer
+#include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
 #include "Parser/LinkageSpec.h"        // for C
 …
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
         struct ForallPointerDecay final {
+                void previsit( ObjectDecl *object );
+                void previsit( FunctionDecl *func );
+                void previsit( ObjectDecl * object );
+                void previsit( FunctionDecl * func );
+                void previsit( StructDecl * aggrDecl );
+                void previsit( UnionDecl * aggrDecl );
         };
 …
                 HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
                 acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
-                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                ReturnChecker::checkFunctionReturns( translationUnit );
+                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
                 Concurrency::applyKeywords( translationUnit );
+                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
                 Concurrency::implementMutexFuncs( translationUnit );
                 Concurrency::implementThreadStarter( translationUnit );
-                ReturnChecker::checkFunctionReturns( translationUnit );
                 mutateAll( translationUnit, compoundliteral );
-                acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
                 acceptAll( translationUnit, finder );
+                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
                 mutateAll( translationUnit, labelAddrFixer );
+        }
 …
                         DWTIterator begin( dwts.begin() ), end( dwts.end() );
                         if ( begin == end ) return;
                         FixFunction fixer;
+                        PassVisitor<FixFunction> fixer;
                         DWTIterator i = begin;
                         *i = (*i)->acceptMutator( fixer );
                         if ( fixer.get_isVoid() ) {
+                        if ( fixer.pass.isVoid ) {
                                 DWTIterator j = i;
                                 ++i;
 …
                                 ++i;
                                 for ( ; i != end; ++i ) {
                                         FixFunction fixer;
+                                        PassVisitor<FixFunction> fixer;
                                         *i = (*i)->acceptMutator( fixer );
                                         if ( fixer.get_isVoid() ) {
+                                        if ( fixer.pass.isVoid ) {
                                                 throw SemanticError( "invalid type void in function type ", func );
                                         } // if
 …
         /// Fix up assertions - flattens assertion lists, removing all trait instances
         void forallFixer( Type * func ) {
                 for ( TypeDecl * type : func->get_forall() ) {
+        void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
+                for ( TypeDecl * type : forall ) {
                         std::list< DeclarationWithType * > asserts;
                         asserts.splice( asserts.end(), type->assertions );
 …
                         // apply FixFunction to every assertion to check for invalid void type
                         for ( DeclarationWithType *& assertion : type->assertions ) {
                                 FixFunction fixer;
+                                PassVisitor<FixFunction> fixer;
                                 assertion = assertion->acceptMutator( fixer );
                                 if ( fixer.get_isVoid() ) {
                                         throw SemanticError( "invalid type void in assertion of function ", func );
+                                if ( fixer.pass.isVoid ) {
+                                        throw SemanticError( "invalid type void in assertion of function ", node );
                                 } // if
                         } // for
 …
         void ForallPointerDecay::previsit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
                         forallFixer( pointer->get_base() );
+                forallFixer( object->type->forall, object );
+                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
+                        forallFixer( pointer->base->forall, object );
                 } // if
                 object->fixUniqueId();
 …
         void ForallPointerDecay::previsit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
+                forallFixer( func->type->forall, func );
                 func->fixUniqueId();
+        }
+        void ForallPointerDecay::previsit( StructDecl * aggrDecl ) {
+                forallFixer( aggrDecl->parameters, aggrDecl );
+        }
+        void ForallPointerDecay::previsit( UnionDecl * aggrDecl ) {
+                forallFixer( aggrDecl->parameters, aggrDecl );
+        }
 …
+                }
                 filter( translationUnit, isTypedef, true );
+        }
 …
                 TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
                 if ( def != typedefNames.end() ) {
                         Type *ret = def->second.first->get_base()->clone();
+                        Type *ret = def->second.first->base->clone();
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->get_parameters().empty() ) {
+                        if ( ! typeInst->parameters.empty() ) {
                                 ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
                                 if ( ! rtt ) {
                                         throw SemanticError("cannot apply type parameters to base type of " + typeInst->get_name());
+                                        throw SemanticError("Cannot apply type parameters to base type of " + typeInst->name);
+                                }
                                 rtt->get_parameters().clear();
                                 cloneAll( typeInst->get_parameters(), rtt->get_parameters() );
                                 mutateAll( rtt->get_parameters(), *visitor );  // recursively fix typedefs on parameters
+                                cloneAll( typeInst->parameters, rtt->parameters );
+                                mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
 …
                 } else {
                         TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
                         assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->get_name().c_str() );
+                        assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() );
                         typeInst->set_baseType( base->second );
                 } // if
                 return typeInst;
+        }
+        struct VarLenChecker : WithShortCircuiting {
+                void previsit( FunctionType * ) { visit_children = false; }
+                void previsit( ArrayType * at ) {
+                        isVarLen |= at->isVarLen;
+                }
+                bool isVarLen = false;
+        };
+        bool isVariableLength( Type * t ) {
+                PassVisitor<VarLenChecker> varLenChecker;
+                maybeAccept( t, varLenChecker );
+                return varLenChecker.pass.isVarLen;
+        }
 …
                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
                         if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
+                                throw SemanticError( "cannot redefine typedef: " + tyDecl->get_name() );
+                                throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+                        }
+                        // cannot redefine VLA typedefs
+                        if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) {
+                                throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+                        }
                 } else {

src/SynTree/AddressExpr.cc

-              r78315272
+              r3f7e12cb
         Type * addrType( Type * type ) {
                 if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
                         return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) );
                 } else {
                         return new PointerType( Type::Qualifiers(), type->clone() );
 …
+}
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
         if ( arg->has_result() ) {
                 if ( arg->get_result()->get_lvalue() ) {
+AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
+        if ( arg->result ) {
+                if ( arg->result->get_lvalue() ) {
                         // lvalue, retains all layers of reference and gains a pointer inside the references
                         set_result( addrType( arg->get_result() ) );
+                        set_result( addrType( arg->result ) );
                 } else {
                         // taking address of non-lvalue -- must be a reference, loses one layer of reference
                         ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
                         set_result( addrType( refType->get_base() ) );
+                        ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
+                        set_result( addrType( refType->base ) );
+                }
                 // result of & is never an lvalue
 …
+}
 void AddressExpr::print( std::ostream &os, int indent ) const {
+void AddressExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Address of:" << std::endl;
         if ( arg ) {
                 os << std::string( indent+2, ' ' );
                 arg->print( os, indent+2 );
+                os << indent+1;
+                arg->print( os, indent+1 );
         } // if
+}
 …
 LabelAddressExpr::~LabelAddressExpr() {}
 void LabelAddressExpr::print( std::ostream & os, int indent ) const {
         os << "Address of label:" << std::endl << std::string( indent+2, ' ' ) << arg;
+void LabelAddressExpr::print( std::ostream & os, Indenter ) const {
+        os << "Address of label:" << arg;
+}

src/SynTree/AggregateDecl.cc

-              r78315272
+              r3f7e12cb
+}
 void AggregateDecl::print( std::ostream &os, int indent ) const {
+void AggregateDecl::print( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
         os << typeString() << " " << get_name() << ":";
+        os << typeString() << " " << name << ":";
         if ( get_linkage() != LinkageSpec::Cforall ) {
                 os << " " << LinkageSpec::linkageName( get_linkage() );
+                os << " " << LinkageSpec::linkageName( linkage );
         } // if
         os << " with body " << has_body() << endl;
+        os << " with body " << has_body();
         if ( ! parameters.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+4 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
         if ( ! members.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with members" << endl;
                 printAll( members, os, indent+4 );
+                os << endl << indent << "... with members" << endl;
+                printAll( members, os, indent+1 );
         } // if
         if ( ! attributes.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
                 printAll( attributes, os, indent+4 );
+                os << endl << indent << "... with attributes" << endl;
+                printAll( attributes, os, indent+1 );
         } // if
+        os << endl;
+}
 void AggregateDecl::printShort( std::ostream &os, int indent ) const {
+void AggregateDecl::printShort( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
+        os << typeString() << " " << get_name();
+        os << string( indent+2, ' ' ) << "with body " << has_body() << endl;
+        os << typeString() << " " << name << " with body " << has_body() << endl;
         if ( ! parameters.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+4 );
+                os << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}

src/SynTree/ApplicationExpr.cc

-              r78315272
+              r3f7e12cb
         set_result( ResolvExpr::extractResultType( function ) );
         assert( has_result() );
+        assert( result );
+}
 ApplicationExpr::ApplicationExpr( const ApplicationExpr &other ) :
                 Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams ) {
+                Expression( other ), function( maybeClone( other.function ) ) {
         cloneAll( other.args, args );
+}
 …
+}
+void printInferParams( const InferredParams & inferParams, std::ostream &os, int indent, int level ) {
+        if ( ! inferParams.empty() ) {
+                os << std::string(indent, ' ') << "with inferred parameters " << level << ":" << std::endl;
+                for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
+                        os << std::string(indent+2, ' ');
+                        Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
+                        os << std::endl;
+                        printInferParams( *i->second.inferParams, os, indent+2, level+1 );
+                } // for
+void ApplicationExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Application of" << std::endl << indent+1;
+        function->print( os, indent+1 );
+        os << std::endl;
+        if ( ! args.empty() ) {
+                os << indent << "... to arguments" << std::endl;
+                printAll( args, os, indent+1 );
         } // if
+}
-void ApplicationExpr::print( std::ostream &os, int indent ) const {
-        os << "Application of" << std::endl << std::string(indent+2, ' ');
-        function->print( os, indent+2 );
-        if ( ! args.empty() ) {
-                os << std::string( indent, ' ' ) << "to arguments" << std::endl;
-                printAll( args, os, indent+2 );
-        } // if
-        printInferParams( inferParams, os, indent+2, 0 );
         Expression::print( os, indent );
+}

src/SynTree/ArrayType.cc

r78315272	r3f7e12cb
39	39	}
40	40
41		void ArrayType::print( std::ostream &os, ~~int~~ indent ) const {
	41	void ArrayType::print( std::ostream &os, Indenter indent ) const {
42	42	Type::print( os, indent );
43	43	if ( isStatic ) {

src/SynTree/AttrType.cc

-              r78315272
+              r3f7e12cb
 // file "LICENCE" distributed with Cforall.
 //
 // AttrType.cc.cc --
+// AttrType.cc.cc --
 //
 // Author           : Richard C. Bilson
 …
+}
 void AttrType::print( std::ostream &os, int indent ) const {
+void AttrType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "attribute " << name << " applied to ";

src/SynTree/Attribute.cc

r78315272	r3f7e12cb
28	28	}
29	29
30		void Attribute::print( std::ostream &os, ~~int~~ indent ) const {
	30	void Attribute::print( std::ostream &os, Indenter indent ) const {
31	31	using std::endl;
32	32	using std::string;
…	…
36	36	if ( ! parameters.empty() ) {
37	37	os << " with parameters: " << endl;
38		printAll( parameters, os, indent );
	38	printAll( parameters, os, indent+1 );
39	39	}
40	40	}

src/SynTree/Attribute.h

-              r78315272
+              r3f7e12cb
 #include <string>  // for string, operator==
+#include "BaseSyntaxNode.h"
+#include "Mutator.h"
+#include "Visitor.h"
 class Expression;
 // GCC attribute
 // https://gcc.gnu.org/onlinedocs/gcc-6.1.0/gcc/Attribute-Syntax.html#Attribute-Syntax
 class Attribute {
+class Attribute : public BaseSyntaxNode {
   public:
+        std::string name;
+        // to keep things nice and tight, use NameExpr for special identifier parameters
+        std::list< Expression * > parameters;
         Attribute( std::string name = "", const std::list< Expression * > & parameters = std::list< Expression * >() ) : name( name ), parameters( parameters ) {}
         Attribute( const Attribute &other );
 …
         bool empty() const { return name == ""; }
+        Attribute * clone() const { return new Attribute( *this ); }
+        void print( std:: ostream &os, int indent = 0 ) const;
+  private:
+        std::string name;
+        // to keep things nice and tight, use NameExpr for special identifier parameters
+        std::list< Expression * > parameters;
+        Attribute * clone() const override { return new Attribute( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Attribute * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };

src/SynTree/BaseSyntaxNode.h

-              r78315272
+              r3f7e12cb
 #include "Common/CodeLocation.h"
+#include "Common/Indenter.h"
 class Visitor;
+class Mutator;
 class BaseSyntaxNode {
 …
         virtual ~BaseSyntaxNode() {}
+        virtual BaseSyntaxNode * clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
+  virtual void print( std::ostream & os, int indent = 0 ) const = 0;
+        virtual BaseSyntaxNode * acceptMutator( Mutator & m ) = 0;
+  /// Notes:
+  /// * each node is responsible for indenting its children.
+  /// * Expressions should not finish with a newline, since the expression's parent has better information.
+        virtual void print( std::ostream & os, Indenter indent = {} ) const = 0;
+  void print( std::ostream & os, unsigned int indent ) {
+    print( os, Indenter{ Indenter::tabsize, indent });
+  }
 };
+std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node );
 // Local Variables: //

src/SynTree/BasicType.cc

-              r78315272
+              r3f7e12cb
 // file "LICENCE" distributed with Cforall.
 //
 // BasicType.cc --
+// BasicType.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 11 12:52:05 2017
 // Update Count     : 9
+// Last Modified On : Mon Sep 25 14:14:03 2017
+// Update Count     : 11
 //
 …
 BasicType::BasicType( const Type::Qualifiers &tq, Kind bt, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), kind( bt ) {}
 void BasicType::print( std::ostream &os, int indent ) const {
+void BasicType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << BasicType::typeNames[ kind ];
 …
           case LongLongSignedInt:
           case LongLongUnsignedInt:
+          case SignedInt128:
+          case UnsignedInt128:
                 return true;
           case Float:

src/SynTree/CommaExpr.cc

-              r78315272
+              r3f7e12cb
 #include "Type.h"            // for Type
 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
                 : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) {
+CommaExpr::CommaExpr( Expression *arg1, Expression *arg2 )
+                : Expression(), arg1( arg1 ), arg2( arg2 ) {
         // xxx - result of a comma expression is never an lvalue, so should set lvalue
         // to false on all result types. Actually doing this causes some strange things
 …
+}
 void CommaExpr::print( std::ostream &os, int indent ) const {
+void CommaExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Comma Expression:" << std::endl;
         os << std::string( indent+2, ' ' );
         arg1->print( os, indent+2 );
+        os << (indent+1);
+        arg1->print( os, indent+1 );
         os << std::endl;
         os << std::string( indent+2, ' ' );
         arg2->print( os, indent+2 );
+        os << (indent+1);
+        arg2->print( os, indent+1 );
         Expression::print( os, indent );
+}

src/SynTree/CompoundStmt.cc

r78315272	r3f7e12cb
29	29
30	30	CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
	31	}
	32
	33	CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
31	34	}
32	35
…	…
70	73	}
71	74
72		void CompoundStmt::print( std::ostream &os, ~~int~~ indent ) const {
73		os << "CompoundStmt" << endl ;
74		printAll( kids, os, indent ~~+ 2~~ );
	75	void CompoundStmt::print( std::ostream &os, Indenter indent ) const {
	76	os << "CompoundStmt" << endl;
	77	printAll( kids, os, indent+1 );
75	78	}
76	79

src/SynTree/Constant.cc

-              r78315272
+              r3f7e12cb
+}
+Constant Constant::from_char( char c ) {
+        return Constant( new BasicType( Type::Qualifiers(), BasicType::Char ), std::to_string( c ), (unsigned long long int)c );
+}
 Constant Constant::from_int( int i ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ), (unsigned long long int)i );
 …
+}
 void Constant::print( std::ostream &os ) const {
+void Constant::print( std::ostream &os, Indenter ) const {
         os << "(" << rep << " " << val.ival;
         if ( type ) {

src/SynTree/Constant.h

-              r78315272
+              r3f7e12cb
 #include <string>     // for string
+#include "BaseSyntaxNode.h"
 #include "Mutator.h"  // for Mutator
 #include "Visitor.h"  // for Visitor
 …
 class Type;
 class Constant {
+class Constant : public BaseSyntaxNode {
   public:
         Constant( Type * type, std::string rep, unsigned long long val );
 …
         Constant( const Constant & other );
         virtual ~Constant();
+        virtual Constant * clone() const { return new Constant( *this ); }
         Type * get_type() { return type; }
 …
         /// generates a boolean constant of the given bool
         static Constant from_bool( bool b );
+        /// generates a char constant of the given char
+        static Constant from_char( char c );
         /// generates an integer constant of the given int
         static Constant from_int( int i );
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Constant * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os ) const;
+        virtual void print( std::ostream & os, Indenter indent = 0 ) const;
   private:
         Type * type;

src/SynTree/DeclStmt.cc

r78315272	r3f7e12cb
33	33	}
34	34
35		void DeclStmt::print( std::ostream &os, ~~int~~ indent ) const {
	35	void DeclStmt::print( std::ostream &os, Indenter indent ) const {
36	36	assert( decl != 0 );
37	37	os << "Declaration of ";

src/SynTree/Declaration.cc

-              r78315272
+              r3f7e12cb
 void Declaration::fixUniqueId() {
+        // don't need to set unique ID twice
+        if ( uniqueId ) return;
         uniqueId = ++lastUniqueId;
         idMap[ uniqueId ] = this;
 …
+}
-std::ostream & operator<<( std::ostream & out, const Declaration * decl ) {
-        if ( decl ){
-                decl->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
 AsmDecl::AsmDecl( AsmStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
 …
+}
 void AsmDecl::print( std::ostream &os, int indent ) const {
+void AsmDecl::print( std::ostream &os, Indenter indent ) const {
         stmt->print( os, indent );
+}
 void AsmDecl::printShort( std::ostream &os, int indent ) const {
+void AsmDecl::printShort( std::ostream &os, Indenter indent ) const {
         stmt->print( os, indent );
+}

src/SynTree/Declaration.h

-              r78315272
+              r3f7e12cb
         void fixUniqueId( void );
         virtual Declaration *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
         virtual Declaration *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
         virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
+        virtual Declaration *clone() const override = 0;
+        virtual void accept( Visitor &v ) override = 0;
+        virtual Declaration *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const = 0;
         static void dumpIds( std::ostream &os );
 …
         //void set_functionSpecifiers( Type::FuncSpecifiers newValue ) { fs = newValue; }
         virtual DeclarationWithType *clone() const = 0;
         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+        virtual DeclarationWithType *clone() const override = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override = 0;
         virtual Type * get_type() const = 0;
 …
         virtual ~ObjectDecl();
         virtual Type * get_type() const { return type; }
         virtual void set_type(Type *newType) { type = newType; }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type *newType) override { type = newType; }
         Initializer *get_init() const { return init; }
 …
         static ObjectDecl * newObject( const std::string & name, Type * type, Initializer * init );
         virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual ObjectDecl *clone() const override { return new ObjectDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         virtual ~FunctionDecl();
         Type * get_type() const { return type; }
         virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+        virtual Type * get_type() const override { return type; }
+        virtual void set_type(Type * t) override { type = strict_dynamic_cast< FunctionType* >( t ); }
         FunctionType * get_functionType() const { return type; }
 …
         void set_statements( CompoundStmt *newValue ) { statements = newValue; }
+        virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        static FunctionDecl * newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements );
+        virtual FunctionDecl *clone() const override { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         virtual std::string typeString() const = 0;
         virtual NamedTypeDecl *clone() const = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual NamedTypeDecl *clone() const override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         typedef NamedTypeDecl Parent;
   public:
         enum Kind { Any, Dtype, Ftype, Ttype };
+        enum Kind { Dtype, Ftype, Ttype };
         Type * init;
 …
         };
         TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init = nullptr );
+        TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init = nullptr );
         TypeDecl( const TypeDecl &other );
         virtual ~TypeDecl();
 …
         TypeDecl * set_init( Type * newValue ) { init = newValue; return this; }
         bool isComplete() const { return kind == Any || sized; }
+        bool isComplete() const { return sized; }
         bool get_sized() const { return sized; }
         TypeDecl * set_sized( bool newValue ) { sized = newValue; return this; }
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
         virtual std::string genTypeString() const;
         virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TypeDecl *clone() const override { return new TypeDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
 …
         TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
         virtual std::string typeString() const;
         virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual std::string typeString() const override;
+        virtual TypedefDecl *clone() const override { return new TypedefDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
 };
 …
         AggregateDecl * set_body( bool body ) { AggregateDecl::body = body; return this; }
         virtual void print( std::ostream &os, int indent = 0 ) const;
         virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
   protected:
         virtual std::string typeString() const = 0;
 …
         bool is_thread() { return kind == DeclarationNode::Thread; }
         virtual StructDecl *clone() const { return new StructDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual StructDecl *clone() const override { return new StructDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
   private:
         DeclarationNode::Aggregate kind;
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         UnionDecl( const UnionDecl &other ) : Parent( other ) {}
         virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual UnionDecl *clone() const override { return new UnionDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         EnumDecl( const EnumDecl &other ) : Parent( other ) {}
         virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual EnumDecl *clone() const override { return new EnumDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         TraitDecl( const TraitDecl &other ) : Parent( other ) {}
         virtual TraitDecl *clone() const { return new TraitDecl( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual TraitDecl *clone() const override { return new TraitDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const override;
 };
 …
         void set_stmt( AsmStmt *newValue ) { stmt = newValue; }
+        virtual AsmDecl *clone() const { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Declaration * decl );
+        virtual AsmDecl *clone() const override { return new AsmDecl( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual AsmDecl *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
+};
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );

src/SynTree/Expression.cc

-              r78315272
+              r3f7e12cb
 #include "GenPoly/Lvalue.h"
+Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
+Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
+        if ( ! inferParams.empty() ) {
+                os << indent << "with inferred parameters " << level << ":" << std::endl;
+                for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
+                        os << indent+1;
+                        Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
+                        os << std::endl;
+                        printInferParams( *i->second.inferParams, os, indent+1, level+1 );
+                } // for
+        } // if
+}
+Expression::Expression() : result( 0 ), env( 0 ) {}
+Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ) {
+}
 Expression::~Expression() {
         delete env;
-        delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
         delete result;
+}
+void Expression::print( std::ostream &os, int indent ) const {
+void Expression::print( std::ostream &os, Indenter indent ) const {
+        printInferParams( inferParams, os, indent+1, 0 );
         if ( env ) {
                 os << std::string( indent, ' ' ) << "with environment:" << std::endl;
                 env->print( os, indent+2 );
+                os << std::endl << indent << "... with environment:" << std::endl;
+                env->print( os, indent+1 );
         } // if
+        if ( argName ) {
+                os << std::string( indent, ' ' ) << "with designator:";
+                argName->print( os, indent+2 );
+        if ( extension ) {
+                os << std::endl << indent << "... with extension:";
         } // if
+        if ( extension ) {
+                os << std::string( indent, ' ' ) << "with extension:";
+        } // if
+}
+ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
+}
+ConstantExpr::ConstantExpr( Constant _c ) : Expression(), constant( _c ) {
         set_result( constant.get_type()->clone() );
+}
 …
 ConstantExpr::~ConstantExpr() {}
 void ConstantExpr::print( std::ostream &os, int indent ) const {
+void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
         os << "constant expression " ;
         constant.print( os );
 …
+}
 VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) {
+VariableExpr::VariableExpr( DeclarationWithType *_var ) : Expression(), var( _var ) {
         assert( var );
         assert( var->get_type() );
 …
+}
 void VariableExpr::print( std::ostream &os, int indent ) const {
+void VariableExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Variable Expression: ";
+        Declaration *decl = get_var();
+        if ( decl != 0) decl->printShort(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        var->printShort(os, indent);
+        Expression::print( os, indent );
+}
+SizeofExpr::SizeofExpr( Expression *expr_ ) :
+                Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
+SizeofExpr::SizeofExpr( Type *type_ ) :
+                Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
 void SizeofExpr::print( std::ostream &os, int indent) const {
+void SizeofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Sizeof Expression on: ";
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        if (isType) type->print(os, indent+1);
+        else expr->print(os, indent+1);
+        Expression::print( os, indent );
+}
+AlignofExpr::AlignofExpr( Expression *expr_ ) :
+                Expression(), expr(expr_), type(0), isType(false) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
+AlignofExpr::AlignofExpr( Type *type_ ) :
+                Expression(), expr(0), type(type_), isType(true) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
 void AlignofExpr::print( std::ostream &os, int indent) const {
+void AlignofExpr::print( std::ostream &os, Indenter indent) const {
         os << "Alignof Expression on: ";
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
+                Expression( _aname ), type(type_), member(member_) {
+        if (isType) type->print(os, indent+1);
+        else expr->print(os, indent+1);
+        Expression::print( os, indent );
+}
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+                Expression(), type(type), member(member) {
+        assert( type );
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
+void UntypedOffsetofExpr::print( std::ostream &os, int indent) const {
+        os << std::string( indent, ' ' ) << "Untyped Offsetof Expression on member " << member << " of ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
+                Expression( _aname ), type(type_), member(member_) {
+void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+        os << "Untyped Offsetof Expression on member " << member << " of ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+                Expression(), type(type), member(member) {
+        assert( member );
+        assert( type );
         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+}
 …
+}
+void OffsetofExpr::print( std::ostream &os, int indent) const {
+        os << std::string( indent, ' ' ) << "Offsetof Expression on member ";
+        if ( member ) {
+                os << member->get_name();
+        } else {
+                os << "<NULL>";
+        }
+        os << " of ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
+void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+        os << "Offsetof Expression on member " << member->name << " of ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+        assert( type );
         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+}
 …
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
+void OffsetPackExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Offset pack expression on ";
+        if ( type ) {
+                type->print(os, indent + 2);
+        } else {
+                os << "<NULL>";
+        }
+        os << std::endl;
+        Expression::print( os, indent );
+}
+AttrExpr::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false) {
+}
+AttrExpr::AttrExpr( Expression *attr, Type *type_, Expression *_aname ) :
+                Expression( _aname ), attr( attr ), expr(0), type(type_), isType(true) {
+void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Offset pack expression on ";
+        type->print(os, indent+1);
+        Expression::print( os, indent );
+}
+AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
+                Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
+}
+AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
+                Expression(), attr( attr ), expr(0), type(type_), isType(true) {
+}
 …
+}
 void AttrExpr::print( std::ostream &os, int indent) const {
+void AttrExpr::print( std::ostream &os, Indenter indent) const {
         os << "Attr ";
         attr->print( os, indent + 2 );
+        attr->print( os, indent+1);
         if ( isType || expr ) {
                 os << "applied to: ";
+                if (isType)
+                        type->print(os, indent + 2);
+                else
+                        expr->print(os, indent + 2);
+                if (isType) type->print(os, indent+1);
+                else expr->print(os, indent+1);
         } // if
+        os << std::endl;
+        Expression::print( os, indent );
+}
+CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+        Expression::print( os, indent );
+}
+CastExpr::CastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
         set_result(toType);
+}
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+CastExpr::CastExpr( Expression *arg_ ) : Expression(), arg(arg_) {
         set_result( new VoidType( Type::Qualifiers() ) );
+}
 …
+}
+void CastExpr::print( std::ostream &os, int indent ) const {
+        os << "Cast of:" << std::endl << std::string( indent+2, ' ' );
+        arg->print(os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
+        os << std::string( indent+2, ' ' );
+void CastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to:";
         if ( result->isVoid() ) {
                 os << "nothing";
+                os << " nothing";
         } else {
+                result->print( os, indent+2 );
+                os << std::endl << indent+1;
+                result->print( os, indent+1 );
         } // if
-        os << std::endl;
         Expression::print( os, indent );
+}
 …
+}
+void VirtualCastExpr::print( std::ostream &os, int indent ) const {
+        os << "Virtual Cast of:" << std::endl << std::string( indent+2, ' ' );
+        arg->print(os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
+        os << std::string( indent+2, ' ' );
+void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Virtual Cast of:" << std::endl << indent+1;
+        arg->print(os, indent+1);
+        os << std::endl << indent << "... to:";
         if ( ! result ) {
                 os << "unknown";
+                os << " unknown";
         } else {
+                result->print( os, indent+2 );
+                os << std::endl << indent+1;
+                result->print( os, indent+1 );
         } // if
+        os << std::endl;
+        Expression::print( os, indent );
+}
+UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+                Expression( _aname ), member(_member), aggregate(_aggregate) {}
+        Expression::print( os, indent );
+}
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+                Expression(), member(member), aggregate(aggregate) {
+        assert( aggregate );
+}
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
 …
+}
+void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
+        os << "Untyped Member Expression, with field: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        get_member()->print(os, indent+4);
+        os << std::string( indent+2, ' ' );
+        Expression *agg = get_aggregate();
+        os << "from aggregate: " << std::endl;
+        if (agg != 0) {
+                os << std::string( indent + 4, ' ' );
+                agg->print(os, indent + 4);
+        }
+        os << std::string( indent+2, ' ' );
+void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Untyped Member Expression, with field: " << std::endl << indent+1;
+        member->print(os, indent+1 );
+        os << indent << "... from aggregate: " << std::endl << indent+1;
+        aggregate->print(os, indent+1);
         Expression::print( os, indent );
+}
 …
+MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
+                Expression( _aname ), member(_member), aggregate(_aggregate) {
+MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+                Expression(), member(member), aggregate(aggregate) {
+        assert( member );
+        assert( aggregate );
         TypeSubstitution sub( makeSub( aggregate->get_result() ) );
 …
+}
 void MemberExpr::print( std::ostream &os, int indent ) const {
+void MemberExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Member Expression, with field: " << std::endl;
+        assert( member );
+        os << std::string( indent + 2, ' ' );
+        member->print( os, indent + 2 );
+        os << std::endl;
+        Expression *agg = get_aggregate();
+        os << std::string( indent, ' ' ) << "from aggregate: " << std::endl;
+        if (agg != 0) {
+                os << std::string( indent + 2, ' ' );
+                agg->print(os, indent + 2);
+        }
+        os << std::string( indent+2, ' ' );
+        Expression::print( os, indent );
+}
+UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
+        os << indent+1;
+        member->print( os, indent+1 );
+        os << std::endl << indent << "... from aggregate: " << std::endl << indent+1;
+        aggregate->print(os, indent + 1);
+        Expression::print( os, indent );
+}
+UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
+                Expression(), function(function), args(args) {}
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
 …
 void UntypedExpr::print( std::ostream &os, int indent ) const {
+void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Applying untyped: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        function->print(os, indent + 2);
+        os << std::string( indent, ' ' ) << "...to: " << std::endl;
+        printAll(args, os, indent + 2);
+        Expression::print( os, indent );
+}
+void UntypedExpr::printArgs( std::ostream &os, int indent ) const {
+        std::list<Expression *>::const_iterator i;
+        for (i = args.begin(); i != args.end(); i++) {
+                os << std::string(indent, ' ' );
+                (*i)->print(os, indent);
+        }
+}
+NameExpr::NameExpr( std::string _name, Expression *_aname ) : Expression( _aname ), name(_name) {
+        assertf(_name != "0", "Zero is not a valid name\n");
+        assertf(_name != "1", "One is not a valid name\n");
+        os << indent+1;
+        function->print(os, indent+1);
+        os << std::endl << indent << "...to: " << std::endl;
+        printAll(args, os, indent+1);
+        Expression::print( os, indent );
+}
+NameExpr::NameExpr( std::string name ) : Expression(), name(name) {
+        assertf(name != "0", "Zero is not a valid name");
+        assertf(name != "1", "One is not a valid name");
+}
 …
 NameExpr::~NameExpr() {}
 void NameExpr::print( std::ostream &os, int indent ) const {
         os << "Name: " << get_name() << std::endl;
         Expression::print( os, indent );
+}
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
+void NameExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Name: " << get_name();
+        Expression::print( os, indent );
+}
+LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
+                Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}
 …
+}
 void LogicalExpr::print( std::ostream &os, int indent )const {
         os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+        os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
         arg1->print(os);
         os << " and ";
         arg2->print(os);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+ConditionalExpr::ConditionalExpr( Expression *arg1_, Expression *arg2_, Expression *arg3_, Expression *_aname ) :
+                Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
+        Expression::print( os, indent );
+}
+ConditionalExpr::ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 ) :
+                Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
 …
+}
+void ConditionalExpr::print( std::ostream &os, int indent ) const {
+        os << "Conditional expression on: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        arg1->print( os, indent+2 );
+        os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
+        arg2->print( os, indent+2 );
+        os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
+        os << std::string( indent+2, ' ' );
+        arg3->print( os, indent+2 );
+        os << std::endl;
+void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Conditional expression on: " << std::endl << indent+1;
+        arg1->print( os, indent+1 );
+        os << indent << "First alternative:" << std::endl << indent+1;
+        arg2->print( os, indent+1 );
+        os << indent << "Second alternative:" << std::endl << indent+1;
+        arg3->print( os, indent+1 );
         Expression::print( os, indent );
+}
 …
 void AsmExpr::print( std::ostream &os, int indent ) const {
+void AsmExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Asm Expression: " << std::endl;
         if ( inout ) inout->print( os, indent + 2 );
         if ( constraint ) constraint->print( os, indent + 2 );
         if ( operand ) operand->print( os, indent + 2 );
+        if ( inout ) inout->print( os, indent+1 );
+        if ( constraint ) constraint->print( os, indent+1 );
+        if ( operand ) operand->print( os, indent+1 );
+}
 …
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
         assert( callExpr->has_result() );
+        assert( callExpr->result );
         set_result( callExpr->get_result()->clone() );
+}
 …
+}
+void ImplicitCopyCtorExpr::print( std::ostream &os, int indent ) const {
+        os <<  "Implicit Copy Constructor Expression: " << std::endl;
+        assert( callExpr );
+        os << std::string( indent+2, ' ' );
+        callExpr->print( os, indent + 2 );
+        os << std::endl << std::string( indent, ' ' ) << "with temporaries:" << std::endl;
+        printAll(tempDecls, os, indent+2);
+        os << std::endl << std::string( indent, ' ' ) << "with return temporaries:" << std::endl;
+        printAll(returnDecls, os, indent+2);
+void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
+        os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
+        callExpr->print( os, indent+1 );
+        os << std::endl << indent << "... with temporaries:" << std::endl;
+        printAll( tempDecls, os, indent+1 );
+        os << std::endl << indent << "... with return temporaries:" << std::endl;
+        printAll( returnDecls, os, indent+1 );
         Expression::print( os, indent );
+}
 …
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
         set_result( maybeClone( arg->get_result() ) );
+        set_result( maybeClone( arg->result ) );
+}
 …
+}
+void ConstructorExpr::print( std::ostream &os, int indent ) const {
+        os <<  "Constructor Expression: " << std::endl;
+        assert( callExpr );
+        os << std::string( indent+2, ' ' );
+void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+        os <<  "Constructor Expression: " << std::endl << indent+1;
         callExpr->print( os, indent + 2 );
         Expression::print( os, indent );
 …
+}
+void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
+        os << "Compound Literal Expression: " << std::endl;
+        os << std::string( indent+2, ' ' );
+        get_result()->print( os, indent + 2 );
+        os << std::string( indent+2, ' ' );
+        initializer->print( os, indent + 2 );
+void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Compound Literal Expression: " << std::endl << indent+1;
+        result->print( os, indent+1 );
+        os << indent+1;
+        initializer->print( os, indent+1 );
         Expression::print( os, indent );
+}
 …
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
 RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
+void RangeExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Range Expression: ";
         low->print( os, indent );
 …
         deleteAll( returnDecls );
+}
 void StmtExpr::print( std::ostream &os, int indent ) const {
         os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
         statements->print( os, indent+2 );
+void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Statement Expression: " << std::endl << indent+1;
+        statements->print( os, indent+1 );
         if ( ! returnDecls.empty() ) {
                 os << std::string( indent+2, ' ' ) << "with returnDecls: ";
                 printAll( returnDecls, os, indent+2 );
+                os << indent+1 << "... with returnDecls: ";
+                printAll( returnDecls, os, indent+1 );
+        }
         if ( ! dtors.empty() ) {
                 os << std::string( indent+2, ' ' ) << "with dtors: ";
                 printAll( dtors, os, indent+2 );
+                os << indent+1 << "... with dtors: ";
+                printAll( dtors, os, indent+1 );
+        }
         Expression::print( os, indent );
 …
         delete var;
+}
 void UniqueExpr::print( std::ostream &os, int indent ) const {
         os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
         get_expr()->print( os, indent+2 );
         if ( get_object() ) {
                 os << std::string( indent+2, ' ' ) << "with decl: ";
                 get_object()->printShort( os, indent+2 );
+void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+        os << "Unique Expression with id:" << id << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        if ( object ) {
+                os << indent << "... with decl: ";
+                get_object()->printShort( os, indent+1 );
+        }
         Expression::print( os, indent );
 …
+}
 void UntypedInitExpr::print( std::ostream & os, int indent ) const {
         os << "Untyped Init Expression" << std::endl << std::string( indent+2, ' ' );
         expr->print( os, indent+2 );
+void UntypedInitExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Untyped Init Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
         if ( ! initAlts.empty() ) {
                 for ( const InitAlternative & alt : initAlts ) {
                         os << std::string( indent+2, ' ' ) <<  "InitAlternative: ";
                         alt.type->print( os, indent+2 );
                         alt.designation->print( os, indent+2 );
+                        os << indent+1 <<  "InitAlternative: ";
+                        alt.type->print( os, indent+1 );
+                        alt.designation->print( os, indent+1 );
+                }
+        }
 …
+}
+void InitExpr::print( std::ostream & os, int indent ) const {
+        os << "Init Expression" << std::endl << std::string( indent+2, ' ' );
+        expr->print( os, indent+2 );
+        os << std::string( indent+2, ' ' ) << "with designation: ";
+        designation->print( os, indent+2 );
+}
+std::ostream & operator<<( std::ostream & out, const Expression * expr ) {
+        if ( expr ) {
+                expr->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+void InitExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Init Expression" << std::endl << indent+1;
+        expr->print( os, indent+1 );
+        os << indent+1 << "... with designation: ";
+        designation->print( os, indent+1 );
+}

src/SynTree/Expression.h

-              r78315272
+              r3f7e12cb
-/// Expression is the root type for all expressions
-class Expression : public BaseSyntaxNode{
-  public:
-        Type * result;
-        TypeSubstitution * env;
-        Expression * argName; // if expression is used as an argument, it can be "designated" by this name
-        bool extension = false;
-        Expression( Expression * _aname = nullptr );
-        Expression( const Expression & other );
-        virtual ~Expression();
-        Type *& get_result() { return result; }
-        const Type * get_result() const { return result; }
-        void set_result( Type * newValue ) { result = newValue; }
-        bool has_result() const { return result != nullptr; }
-        TypeSubstitution * get_env() const { return env; }
-        void set_env( TypeSubstitution * newValue ) { env = newValue; }
-        Expression * get_argName() const { return argName; }
-        void set_argName( Expression * name ) { argName = name; }
-        bool get_extension() const { return extension; }
-        Expression * set_extension( bool exten ) { extension = exten; return this; }
-        virtual Expression * clone() const = 0;
-        virtual void accept( Visitor & v ) = 0;
-        virtual Expression * acceptMutator( Mutator & m ) = 0;
-        virtual void print( std::ostream & os, int indent = 0 ) const;
-};
 struct ParamEntry;
 …
         Type * actualType;
         Type * formalType;
         Expression* expr;
+        Expression * expr;
         std::unique_ptr< InferredParams > inferParams;
+};
+/// Expression is the root type for all expressions
+class Expression : public BaseSyntaxNode {
+  public:
+        Type * result;
+        TypeSubstitution * env;
+        bool extension = false;
+        InferredParams inferParams;
+        Expression();
+        Expression( const Expression & other );
+        virtual ~Expression();
+        Type *& get_result() { return result; }
+        const Type * get_result() const { return result; }
+        void set_result( Type * newValue ) { result = newValue; }
+        TypeSubstitution * get_env() const { return env; }
+        void set_env( TypeSubstitution * newValue ) { env = newValue; }
+        bool get_extension() const { return extension; }
+        Expression * set_extension( bool exten ) { extension = exten; return this; }
+        InferredParams & get_inferParams() { return inferParams; }
+        virtual Expression * clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Expression * acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         Expression * function;
         std::list<Expression *> args;
-        InferredParams inferParams;
         ApplicationExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
 …
         void set_function( Expression * newValue ) { function = newValue; }
         std::list<Expression *>& get_args() { return args; }
-        InferredParams & get_inferParams() { return inferParams; }
         virtual ApplicationExpr * clone() const { return new ApplicationExpr( * this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::list<Expression*> args;
         UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >(), Expression *_aname = nullptr );
+        UntypedExpr( Expression * function, const std::list<Expression *> & args = std::list< Expression * >() );
         UntypedExpr( const UntypedExpr & other );
         virtual ~UntypedExpr();
 …
         void set_function( Expression * newValue ) { function = newValue; }
-        void set_args( std::list<Expression *> & listArgs ) { args = listArgs; }
         std::list<Expression*>::iterator begin_args() { return args.begin(); }
         std::list<Expression*>::iterator end_args() { return args.end(); }
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void printArgs(std::ostream & os, int indent = 0) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::string name;
         NameExpr( std::string name, Expression *_aname = nullptr );
+        NameExpr( std::string name );
         NameExpr( const NameExpr & other );
         virtual ~NameExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg;
         AddressExpr( Expression * arg, Expression *_aname = nullptr );
+        AddressExpr( Expression * arg );
         AddressExpr( const AddressExpr & other );
         virtual ~AddressExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg;
         CastExpr( Expression * arg, Expression *_aname = nullptr );
         CastExpr( Expression * arg, Type * toType, Expression *_aname = nullptr );
+        CastExpr( Expression * arg );
+        CastExpr( Expression * arg, Type * toType );
         CastExpr( const CastExpr & other );
         virtual ~CastExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * aggregate;
         UntypedMemberExpr( Expression * member, Expression * aggregate, Expression *_aname = nullptr );
+        UntypedMemberExpr( Expression * member, Expression * aggregate );
         UntypedMemberExpr( const UntypedMemberExpr & other );
         virtual ~UntypedMemberExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * aggregate;
         MemberExpr( DeclarationWithType * member, Expression * aggregate, Expression *_aname = nullptr );
+        MemberExpr( DeclarationWithType * member, Expression * aggregate );
         MemberExpr( const MemberExpr & other );
         virtual ~MemberExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         DeclarationWithType * var;
         VariableExpr( DeclarationWithType * var, Expression *_aname = nullptr );
+        VariableExpr( DeclarationWithType * var );
         VariableExpr( const VariableExpr & other );
         virtual ~VariableExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Constant constant;
         ConstantExpr( Constant constant, Expression *_aname = nullptr );
+        ConstantExpr( Constant constant );
         ConstantExpr( const ConstantExpr & other );
         virtual ~ConstantExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         bool isType;
         SizeofExpr( Expression * expr, Expression *_aname = nullptr );
+        SizeofExpr( Expression * expr );
         SizeofExpr( const SizeofExpr & other );
         SizeofExpr( Type * type, Expression *_aname = nullptr );
+        SizeofExpr( Type * type );
         virtual ~SizeofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         bool isType;
         AlignofExpr( Expression * expr, Expression *_aname = nullptr );
+        AlignofExpr( Expression * expr );
         AlignofExpr( const AlignofExpr & other );
         AlignofExpr( Type * type, Expression *_aname = nullptr );
+        AlignofExpr( Type * type );
         virtual ~AlignofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::string member;
         UntypedOffsetofExpr( Type * type, const std::string & member, Expression *_aname = nullptr );
+        UntypedOffsetofExpr( Type * type, const std::string & member );
         UntypedOffsetofExpr( const UntypedOffsetofExpr & other );
         virtual ~UntypedOffsetofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         DeclarationWithType * member;
         OffsetofExpr( Type * type, DeclarationWithType * member, Expression *_aname = nullptr );
+        OffsetofExpr( Type * type, DeclarationWithType * member );
         OffsetofExpr( const OffsetofExpr & other );
         virtual ~OffsetofExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         StructInstType * type;
         OffsetPackExpr( StructInstType * type_, Expression * aname_ = 0 );
+        OffsetPackExpr( StructInstType * type );
         OffsetPackExpr( const OffsetPackExpr & other );
         virtual ~OffsetPackExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         bool isType;
         AttrExpr(Expression * attr, Expression * expr, Expression *_aname = nullptr );
+        AttrExpr(Expression * attr, Expression * expr );
         AttrExpr( const AttrExpr & other );
         AttrExpr( Expression * attr, Type * type, Expression *_aname = nullptr );
+        AttrExpr( Expression * attr, Type * type );
         virtual ~AttrExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg2;
         LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true, Expression *_aname = nullptr );
+        LogicalExpr( Expression * arg1, Expression * arg2, bool andp = true );
         LogicalExpr( const LogicalExpr & other );
         virtual ~LogicalExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
   private:
 …
         Expression * arg3;
         ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3, Expression *_aname = nullptr );
+        ConditionalExpr( Expression * arg1, Expression * arg2, Expression * arg3 );
         ConditionalExpr( const ConditionalExpr & other );
         virtual ~ConditionalExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         Expression * arg2;
         CommaExpr( Expression * arg1, Expression * arg2, Expression *_aname = nullptr );
+        CommaExpr( Expression * arg1, Expression * arg2 );
         CommaExpr( const CommaExpr & other );
         virtual ~CommaExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
         // https://gcc.gnu.org/onlinedocs/gcc-4.7.1/gcc/Machine-Constraints.html#Machine-Constraints
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::list<Expression*> exprs;
         UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        UntypedTupleExpr( const std::list< Expression * > & exprs );
         UntypedTupleExpr( const UntypedTupleExpr & other );
         virtual ~UntypedTupleExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         std::list<Expression*> exprs;
         TupleExpr( const std::list< Expression * > & exprs, Expression *_aname = nullptr );
+        TupleExpr( const std::list< Expression * > & exprs );
         TupleExpr( const TupleExpr & other );
         virtual ~TupleExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         StmtExpr * stmtExpr = nullptr;
         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
+        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls );
         TupleAssignExpr( const TupleAssignExpr & other );
         virtual ~TupleAssignExpr();
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 private:
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Expression * expr );
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
+};
 // Local Variables: //

src/SynTree/FunctionDecl.cc

-              r78315272
+              r3f7e12cb
 #include "Statement.h"           // for CompoundStmt
 #include "Type.h"                // for Type, FunctionType, Type::FuncSpecif...
+#include "VarExprReplacer.h"
 extern bool translation_unit_nomain;
 …
 FunctionDecl::FunctionDecl( const FunctionDecl &other )
                 : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ) {
+        VarExprReplacer::DeclMap declMap;
+        for ( auto p : group_iterate( other.type->parameters, type->parameters ) ) {
+                declMap[ std::get<0>(p) ] = std::get<1>(p);
+        }
+        for ( auto p : group_iterate( other.type->returnVals, type->returnVals ) ) {
+                declMap[ std::get<0>(p) ] = std::get<1>(p);
+        }
+        if ( ! declMap.empty() ) {
+                VarExprReplacer replacer( declMap );
+                accept( replacer );
+        }
+}
 …
+}
+void FunctionDecl::print( std::ostream &os, int indent ) const {
+FunctionDecl * FunctionDecl::newFunction( const std::string & name, FunctionType * type, CompoundStmt * statements ) {
+        return new FunctionDecl( name, Type::StorageClasses(), LinkageSpec::C, type, statements );
+}
+void FunctionDecl::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         using std::string;
         if ( get_name() != "" ) {
                 os << get_name() << ": ";
+        if ( name != "" ) {
+                os << name << ": ";
         } // if
         if ( get_linkage() != LinkageSpec::Cforall ) {
                 os << LinkageSpec::linkageName( get_linkage() ) << " ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
         printAll( get_attributes(), os, indent );
+        printAll( attributes, os, indent );
         get_storageClasses().print( os );
         get_funcSpec().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";
 …
         if ( statements ) {
+                os << string( indent + 2, ' ' ) << "with body " << endl;
+                os << string( indent + 4, ' ' );
+                statements->print( os, indent + 4 );
+                os << indent << "... with body " << endl << indent+1;
+                statements->print( os, indent+1 );
         } // if
+}
 void FunctionDecl::printShort( std::ostream &os, int indent ) const {
+void FunctionDecl::printShort( std::ostream &os, Indenter indent ) const {
         using std::endl;
         using std::string;
         if ( get_name() != "" ) {
                 os << get_name() << ": ";
+        if ( name != "" ) {
+                os << name << ": ";
         } // if
-        // xxx - should printShort print attributes?
         get_storageClasses().print( os );
         get_funcSpec().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";

src/SynTree/FunctionType.cc

-              r78315272
+              r3f7e12cb
+}
 void FunctionType::print( std::ostream &os, int indent ) const {
+void FunctionType::print( std::ostream &os, Indenter indent ) const {
         using std::string;
         using std::endl;
 …
         os << "function" << endl;
         if ( ! parameters.empty() ) {
                 os << string( indent + 2, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent + 4 );
+                os << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
                 if ( isVarArgs ) {
                         os << string( indent + 4, ' ' ) << "and a variable number of other arguments" << endl;
+                        os << indent+1 << "and a variable number of other arguments" << endl;
                 } // if
         } else if ( isVarArgs ) {
                 os << string( indent + 4, ' ' ) << "accepting unspecified arguments" << endl;
+                os << indent+1 << "accepting unspecified arguments" << endl;
         } // if
         os << string( indent + 2, ' ' ) << "returning ";
+        os << indent << "... returning ";
         if ( returnVals.empty() ) {
                 os << endl << string( indent + 4, ' ' ) << "nothing " << endl;
+                os << "nothing " << endl;
         } else {
                 os << endl;
                 printAll( returnVals, os, indent + 4 );
+                printAll( returnVals, os, indent+1 );
         } // if
+}

src/SynTree/Initializer.cc

-              r78315272
+              r3f7e12cb
+}
 void Designation::print( std::ostream &os, int indent ) const {
+void Designation::print( std::ostream &os, Indenter indent ) const {
         if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: " << std::endl;
+                for ( std::list < Expression * >::const_iterator i = designators.begin(); i != designators.end(); i++ ) {
+                        os << std::string(indent + 4, ' ' );
+                        ( *i )->print(os, indent + 4 );
+                os << "... designated by: " << std::endl;
+                for ( const Expression * d : designators ) {
+                        os << indent+1;
+                        d->print(os, indent+1 );
+                        os << std::endl;
+                }
-                os << std::endl;
         } // if
+}
 …
+}
+void SingleInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ' ) << "Simple Initializer: " << std::endl;
+        os << std::string(indent+4, ' ' );
+        value->print( os, indent+4 );
+void SingleInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Simple Initializer: ";
+        value->print( os, indent );
+}
 …
+}
+void ListInit::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Compound initializer:  " << std::endl;
+        for ( Designation * d : designations ) {
+                d->print( os, indent + 2 );
+        }
+        for ( const Initializer * init : initializers ) {
+                init->print( os, indent + 2 );
+void ListInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Compound initializer: " << std::endl;
+        for ( auto p : group_iterate( designations, initializers ) ) {
+                const Designation * d = std::get<0>(p);
+                const Initializer * init = std::get<1>(p);
+                os << indent+1;
+                init->print( os, indent+1 );
                 os << std::endl;
+                if ( ! d->designators.empty() ) {
+                        os << indent+1;
+                        d->print( os, indent+1 );
+                }
+        }
+}
 …
+}
 void ConstructorInit::print( std::ostream &os, int indent ) const {
         os << std::endl << std::string(indent, ' ') << "Constructor initializer: " << std::endl;
+void ConstructorInit::print( std::ostream &os, Indenter indent ) const {
+        os << "Constructor initializer: " << std::endl;
         if ( ctor ) {
+                os << std::string(indent+2, ' ');
+                os << "initially constructed with ";
+                ctor->print( os, indent+4 );
+                os << indent << "... initially constructed with ";
+                ctor->print( os, indent+1 );
         } // if
         if ( dtor ) {
+                os << std::string(indent+2, ' ');
+                os << "destructed with ";
+                dtor->print( os, indent+4 );
+                os << indent << "... destructed with ";
+                dtor->print( os, indent+1 );
+        }
         if ( init ) {
+                os << std::string(indent+2, ' ');
+                os << "with fallback C-style initializer: ";
+                init->print( os, indent+4 );
+                os << indent << "... with fallback C-style initializer: ";
+                init->print( os, indent+1 );
+        }
+}
-std::ostream & operator<<( std::ostream & out, const Initializer * init ) {
-        if ( init ) {
-                init->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}
-std::ostream & operator<<( std::ostream & out, const Designation * des ) {
-        if ( des ) {
-                des->print( out );
-        } else {
-                out << "nullptr";
+        }
-        return out;
+}

src/SynTree/Initializer.h

-              r78315272
+              r3f7e12cb
         std::list< Expression * > & get_designators() { return designators; }
         virtual Designation * clone() const { return new Designation( *this ); };
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Designation * acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual Designation * clone() const override { return new Designation( *this ); };
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Designation * acceptMutator( Mutator &m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         bool get_maybeConstructed() { return maybeConstructed; }
         virtual Initializer *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
         virtual Initializer *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual Initializer *clone() const override = 0;
+        virtual void accept( Visitor &v ) override = 0;
+        virtual Initializer *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override = 0;
   private:
         bool maybeConstructed;
 …
         void set_value( Expression *newValue ) { value = newValue; }
         virtual SingleInit *clone() const { return new SingleInit( *this); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual SingleInit *clone() const override { return new SingleInit( *this); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         const_iterator end() const { return initializers.end(); }
         virtual ListInit *clone() const { return new ListInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ListInit *clone() const override { return new ListInit( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         Statement * ctor;
         Statement * dtor;
+        // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
+        // if an appropriate constructor definition is not found by the resolver
+        Initializer * init;
         ConstructorInit( Statement * ctor, Statement * dtor, Initializer * init );
 …
         Initializer * get_init() const { return init; }
         ConstructorInit *clone() const { return new ConstructorInit( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        ConstructorInit *clone() const override { return new ConstructorInit( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
-        // C-style initializer made up of SingleInit and ListInit nodes to use as a fallback
-        // if an appropriate constructor definition is not found by the resolver
-        Initializer * init;
 };
-std::ostream & operator<<( std::ostream & out, const Initializer * init );
-std::ostream & operator<<( std::ostream & out, const Designation * des );
 // Local Variables: //

src/SynTree/Mutator.cc

-              r78315272
+              r3f7e12cb
 #include <list>                // for list
+#include "Attribute.h"         // for Attribute
 #include "Declaration.h"       // for ObjectDecl, Declaration, DeclarationWi...
 #include "Expression.h"        // for Expression, ConstantExpr, ConditionalExpr
 …
         objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
         objectDecl->set_bitfieldWidth( maybeMutate( objectDecl->get_bitfieldWidth(), *this ) );
+        mutateAll( objectDecl->attributes, *this );
         return objectDecl;
+}
 …
         functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
         functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+        mutateAll( functionDecl->attributes, *this );
         return functionDecl;
+}
 …
+}
+Attribute * Mutator::mutate( Attribute * attribute ) {
+        mutateAll( attribute->parameters, *this );
+        return attribute;
+}
+TypeSubstitution * Mutator::mutate( TypeSubstitution * sub ) {
+        for ( auto & p : sub->typeEnv ) {
+                p.second = maybeMutate( p.second, *this );
+        }
+        for ( auto & p : sub->varEnv ) {
+                p.second = maybeMutate( p.second, *this );
+        }
+        return sub;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Mutator.h

-              r78315272
+              r3f7e12cb
         virtual ~Mutator();
   public:
         virtual DeclarationWithType* mutate( ObjectDecl *objectDecl );
         virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
         virtual Declaration* mutate( StructDecl *aggregateDecl );
         virtual Declaration* mutate( UnionDecl *aggregateDecl );
         virtual Declaration* mutate( EnumDecl *aggregateDecl );
         virtual Declaration* mutate( TraitDecl *aggregateDecl );
         virtual Declaration* mutate( TypeDecl *typeDecl );
         virtual Declaration* mutate( TypedefDecl *typeDecl );
         virtual AsmDecl* mutate( AsmDecl *asmDecl );
+        virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
+        virtual DeclarationWithType * mutate( FunctionDecl * functionDecl );
+        virtual Declaration * mutate( StructDecl * aggregateDecl );
+        virtual Declaration * mutate( UnionDecl * aggregateDecl );
+        virtual Declaration * mutate( EnumDecl * aggregateDecl );
+        virtual Declaration * mutate( TraitDecl * aggregateDecl );
+        virtual Declaration * mutate( TypeDecl * typeDecl );
+        virtual Declaration * mutate( TypedefDecl * typeDecl );
+        virtual AsmDecl * mutate( AsmDecl * asmDecl );
         virtual CompoundStmt* mutate( CompoundStmt *compoundStmt );
         virtual Statement* mutate( ExprStmt *exprStmt );
         virtual Statement* mutate( AsmStmt *asmStmt );
         virtual Statement* mutate( IfStmt *ifStmt );
         virtual Statement* mutate( WhileStmt *whileStmt );
         virtual Statement* mutate( ForStmt *forStmt );
         virtual Statement* mutate( SwitchStmt *switchStmt );
         virtual Statement* mutate( CaseStmt *caseStmt );
         virtual Statement* mutate( BranchStmt *branchStmt );
         virtual Statement* mutate( ReturnStmt *returnStmt );
         virtual Statement* mutate( ThrowStmt *throwStmt );
         virtual Statement* mutate( TryStmt *tryStmt );
         virtual Statement* mutate( CatchStmt *catchStmt );
         virtual Statement* mutate( FinallyStmt *catchStmt );
         virtual Statement* mutate( WaitForStmt *waitforStmt );
         virtual NullStmt* mutate( NullStmt *nullStmt );
         virtual Statement* mutate( DeclStmt *declStmt );
         virtual Statement* mutate( ImplicitCtorDtorStmt *impCtorDtorStmt );
+        virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
+        virtual Statement * mutate( ExprStmt * exprStmt );
+        virtual Statement * mutate( AsmStmt * asmStmt );
+        virtual Statement * mutate( IfStmt * ifStmt );
+        virtual Statement * mutate( WhileStmt * whileStmt );
+        virtual Statement * mutate( ForStmt * forStmt );
+        virtual Statement * mutate( SwitchStmt * switchStmt );
+        virtual Statement * mutate( CaseStmt * caseStmt );
+        virtual Statement * mutate( BranchStmt * branchStmt );
+        virtual Statement * mutate( ReturnStmt * returnStmt );
+        virtual Statement * mutate( ThrowStmt * throwStmt );
+        virtual Statement * mutate( TryStmt * tryStmt );
+        virtual Statement * mutate( CatchStmt * catchStmt );
+        virtual Statement * mutate( FinallyStmt * catchStmt );
+        virtual Statement * mutate( WaitForStmt * waitforStmt );
+        virtual NullStmt * mutate( NullStmt * nullStmt );
+        virtual Statement * mutate( DeclStmt * declStmt );
+        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt );
         virtual Expression* mutate( ApplicationExpr *applicationExpr );
         virtual Expression* mutate( UntypedExpr *untypedExpr );
         virtual Expression* mutate( NameExpr *nameExpr );
         virtual Expression* mutate( AddressExpr *castExpr );
         virtual Expression* mutate( LabelAddressExpr *labAddressExpr );
         virtual Expression* mutate( CastExpr *castExpr );
         virtual Expression* mutate( VirtualCastExpr *castExpr );
         virtual Expression* mutate( UntypedMemberExpr *memberExpr );
         virtual Expression* mutate( MemberExpr *memberExpr );
         virtual Expression* mutate( VariableExpr *variableExpr );
         virtual Expression* mutate( ConstantExpr *constantExpr );
         virtual Expression* mutate( SizeofExpr *sizeofExpr );
         virtual Expression* mutate( AlignofExpr *alignofExpr );
         virtual Expression* mutate( UntypedOffsetofExpr *offsetofExpr );
         virtual Expression* mutate( OffsetofExpr *offsetofExpr );
         virtual Expression* mutate( OffsetPackExpr *offsetPackExpr );
         virtual Expression* mutate( AttrExpr *attrExpr );
         virtual Expression* mutate( LogicalExpr *logicalExpr );
         virtual Expression* mutate( ConditionalExpr *conditionalExpr );
         virtual Expression* mutate( CommaExpr *commaExpr );
         virtual Expression* mutate( TypeExpr *typeExpr );
         virtual Expression* mutate( AsmExpr *asmExpr );
         virtual Expression* mutate( ImplicitCopyCtorExpr *impCpCtorExpr );
         virtual Expression* mutate( ConstructorExpr *ctorExpr );
         virtual Expression* mutate( CompoundLiteralExpr *compLitExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
         virtual Expression* mutate( UntypedTupleExpr *tupleExpr );
         virtual Expression* mutate( TupleExpr *tupleExpr );
         virtual Expression* mutate( TupleIndexExpr *tupleExpr );
         virtual Expression* mutate( TupleAssignExpr *assignExpr );
         virtual Expression* mutate( StmtExpr * stmtExpr );
         virtual Expression* mutate( UniqueExpr * uniqueExpr );
         virtual Expression* mutate( UntypedInitExpr * initExpr );
         virtual Expression* mutate( InitExpr * initExpr );
+        virtual Expression* mutate( ApplicationExpr * applicationExpr );
+        virtual Expression* mutate( UntypedExpr * untypedExpr );
+        virtual Expression* mutate( NameExpr * nameExpr );
+        virtual Expression* mutate( AddressExpr * castExpr );
+        virtual Expression* mutate( LabelAddressExpr * labAddressExpr );
+        virtual Expression* mutate( CastExpr * castExpr );
+        virtual Expression* mutate( VirtualCastExpr * castExpr );
+        virtual Expression* mutate( UntypedMemberExpr * memberExpr );
+        virtual Expression* mutate( MemberExpr * memberExpr );
+        virtual Expression* mutate( VariableExpr * variableExpr );
+        virtual Expression* mutate( ConstantExpr * constantExpr );
+        virtual Expression* mutate( SizeofExpr * sizeofExpr );
+        virtual Expression* mutate( AlignofExpr * alignofExpr );
+        virtual Expression* mutate( UntypedOffsetofExpr * offsetofExpr );
+        virtual Expression* mutate( OffsetofExpr * offsetofExpr );
+        virtual Expression* mutate( OffsetPackExpr * offsetPackExpr );
+        virtual Expression* mutate( AttrExpr * attrExpr );
+        virtual Expression* mutate( LogicalExpr * logicalExpr );
+        virtual Expression* mutate( ConditionalExpr * conditionalExpr );
+        virtual Expression* mutate( CommaExpr * commaExpr );
+        virtual Expression* mutate( TypeExpr * typeExpr );
+        virtual Expression* mutate( AsmExpr * asmExpr );
+        virtual Expression* mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+        virtual Expression* mutate( ConstructorExpr * ctorExpr );
+        virtual Expression* mutate( CompoundLiteralExpr * compLitExpr );
+        virtual Expression* mutate( RangeExpr * rangeExpr );
+        virtual Expression* mutate( UntypedTupleExpr * tupleExpr );
+        virtual Expression* mutate( TupleExpr * tupleExpr );
+        virtual Expression* mutate( TupleIndexExpr * tupleExpr );
+        virtual Expression* mutate( TupleAssignExpr * assignExpr );
+        virtual Expression* mutate( StmtExpr  * stmtExpr );
+        virtual Expression* mutate( UniqueExpr  * uniqueExpr );
+        virtual Expression* mutate( UntypedInitExpr  * initExpr );
+        virtual Expression* mutate( InitExpr  * initExpr );
         virtual Type* mutate( VoidType *basicType );
         virtual Type* mutate( BasicType *basicType );
         virtual Type* mutate( PointerType *pointerType );
         virtual Type* mutate( ArrayType *arrayType );
         virtual Type* mutate( ReferenceType *refType );
         virtual Type* mutate( FunctionType *functionType );
         virtual Type* mutate( StructInstType *aggregateUseType );
         virtual Type* mutate( UnionInstType *aggregateUseType );
         virtual Type* mutate( EnumInstType *aggregateUseType );
         virtual Type* mutate( TraitInstType *aggregateUseType );
         virtual Type* mutate( TypeInstType *aggregateUseType );
         virtual Type* mutate( TupleType *tupleType );
         virtual Type* mutate( TypeofType *typeofType );
         virtual Type* mutate( AttrType *attrType );
         virtual Type* mutate( VarArgsType *varArgsType );
         virtual Type* mutate( ZeroType *zeroType );
         virtual Type* mutate( OneType *oneType );
+        virtual Type * mutate( VoidType * basicType );
+        virtual Type * mutate( BasicType * basicType );
+        virtual Type * mutate( PointerType * pointerType );
+        virtual Type * mutate( ArrayType * arrayType );
+        virtual Type * mutate( ReferenceType * refType );
+        virtual Type * mutate( FunctionType * functionType );
+        virtual Type * mutate( StructInstType * aggregateUseType );
+        virtual Type * mutate( UnionInstType * aggregateUseType );
+        virtual Type * mutate( EnumInstType * aggregateUseType );
+        virtual Type * mutate( TraitInstType * aggregateUseType );
+        virtual Type * mutate( TypeInstType * aggregateUseType );
+        virtual Type * mutate( TupleType * tupleType );
+        virtual Type * mutate( TypeofType * typeofType );
+        virtual Type * mutate( AttrType * attrType );
+        virtual Type * mutate( VarArgsType * varArgsType );
+        virtual Type * mutate( ZeroType * zeroType );
+        virtual Type * mutate( OneType * oneType );
         virtual Designation* mutate( Designation *designation );
         virtual Initializer* mutate( SingleInit *singleInit );
         virtual Initializer* mutate( ListInit *listInit );
         virtual Initializer* mutate( ConstructorInit *ctorInit );
+        virtual Designation * mutate( Designation * designation );
+        virtual Initializer * mutate( SingleInit * singleInit );
+        virtual Initializer * mutate( ListInit * listInit );
+        virtual Initializer * mutate( ConstructorInit * ctorInit );
         virtual Subrange *mutate( Subrange *subrange );
+        virtual Subrange * mutate( Subrange * subrange );
+        virtual Constant *mutate( Constant *constant );
+        virtual Constant * mutate( Constant * constant );
+        virtual Attribute * mutate( Attribute * attribute );
+        virtual TypeSubstitution * mutate( TypeSubstitution * sub );
   private:
         virtual Declaration* handleAggregateDecl(AggregateDecl *aggregateDecl );
         virtual Declaration* handleNamedTypeDecl(NamedTypeDecl *typeDecl );
         virtual Type* handleReferenceToType(ReferenceToType *aggregateUseType );
+        virtual Declaration * handleAggregateDecl(AggregateDecl * aggregateDecl );
+        virtual Declaration * handleNamedTypeDecl(NamedTypeDecl * typeDecl );
+        virtual Type * handleReferenceToType(ReferenceToType * aggregateUseType );
 };

src/SynTree/NamedTypeDecl.cc

-              r78315272
+              r3f7e12cb
+}
 void NamedTypeDecl::print( std::ostream &os, int indent ) const {
+void NamedTypeDecl::print( std::ostream &os, Indenter indent ) const {
         using namespace std;
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+        } // if
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( get_linkage() ) << " ";
+        if ( name != "" ) os << name << ": ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
         get_storageClasses().print( os );
 …
         if ( base ) {
                 os << " for ";
                 base->print( os, indent );
+                base->print( os, indent+1 );
         } // if
         if ( ! parameters.empty() ) {
                 os << endl << string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
         if ( ! assertions.empty() ) {
                 os << endl << string( indent, ' ' ) << "with assertions" << endl;
                 printAll( assertions, os, indent+2 );
+                os << endl << indent << "... with assertions" << endl;
+                printAll( assertions, os, indent+1 );
         } // if
+}
 void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
+void NamedTypeDecl::printShort( std::ostream &os, Indenter indent ) const {
         using namespace std;
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+        } // if
+        if ( name != "" ) os << name << ": ";
         get_storageClasses().print( os );
         os << typeString();
         if ( base ) {
                 os << " for ";
                 base->print( os, indent );
+                base->print( os, indent+1 );
         } // if
         if ( ! parameters.empty() ) {
                 os << endl << string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}

src/SynTree/ObjectDecl.cc

-              r78315272
+              r3f7e12cb
+}
+void ObjectDecl::print( std::ostream &os, int indent ) const {
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+void ObjectDecl::print( std::ostream &os, Indenter indent ) const {
+        if ( name != "" ) os << name << ": ";
+        if ( linkage != LinkageSpec::Cforall ) {
+                os << LinkageSpec::linkageName( linkage ) << " ";
         } // if
-        if ( get_linkage() != LinkageSpec::Cforall ) {
-                os << LinkageSpec::linkageName( get_linkage() ) << " ";
-        } // if
-        printAll( get_attributes(), os, indent );
         get_storageClasses().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << " untyped entity ";
 …
         if ( init ) {
+                os << " with initializer " << std::endl;
+                init->print( os, indent+2 );
+                os << std::endl << std::string(indent+2, ' ');
+                os << "maybeConstructed? " << init->get_maybeConstructed();
+                os << " with initializer (" << (init->get_maybeConstructed() ? "maybe constructed" : "not constructed") << ")" << std::endl << indent+1;
+                init->print( os, indent+1 );
+                os << std::endl;
         } // if
+        if ( ! attributes.empty() ) {
+                os << std::endl << indent << "... with attributes: " << std::endl;
+                printAll( attributes, os, indent+1 );
+        }
         if ( bitfieldWidth ) {
+                os << std::string(indent, ' ');
+                os << " with bitfield width ";
+                os << indent << " with bitfield width ";
                 bitfieldWidth->print( os );
         } // if
+}
 void ObjectDecl::printShort( std::ostream &os, int indent ) const {
+void ObjectDecl::printShort( std::ostream &os, Indenter indent ) const {
 #if 0
         if ( get_mangleName() != "") {
 …
         } else
 #endif
+        if ( get_name() != "" ) {
+                os << get_name() << ": ";
+        } // if
+        // xxx - should printShort print attributes?
+        if ( name != "" ) os << name << ": ";
         get_storageClasses().print( os );
         if ( get_type() ) {
                 get_type()->print( os, indent );
+        if ( type ) {
+                type->print( os, indent );
         } else {
                 os << "untyped entity ";

src/SynTree/PointerType.cc

r78315272	r3f7e12cb
41	41	}
42	42
43		void PointerType::print( std::ostream &os, ~~int~~ indent ) const {
	43	void PointerType::print( std::ostream &os, Indenter indent ) const {
44	44	Type::print( os, indent );
45	45	if ( ! is_array() ) {

src/SynTree/ReferenceToType.cc

-              r78315272
+              r3f7e12cb
 //
-#include <stddef.h>          // for NULL
 #include <cassert>           // for assert
 #include <list>              // for list, _List_const_iterator, list<>::cons...
 …
+}
 void ReferenceToType::print( std::ostream &os, int indent ) const {
+void ReferenceToType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 …
         os << "instance of " << typeString() << " " << name << " ";
         if ( ! parameters.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}
 …
 std::list<TypeDecl*>* StructInstType::get_baseParameters() {
         if ( ! baseStruct ) return NULL;
+        if ( ! baseStruct ) return nullptr;
         return &baseStruct->get_parameters();
+}
 …
+}
 void StructInstType::print( std::ostream &os, int indent ) const {
+void StructInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         if ( baseStruct == NULL ) ReferenceToType::print( os, indent );
+        if ( baseStruct == nullptr ) ReferenceToType::print( os, indent );
         else {
                 Type::print( os, indent );
                 os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
                 if ( ! parameters.empty() ) {
                         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                         printAll( parameters, os, indent+2 );
+                        os << endl << indent << "... with parameters" << endl;
+                        printAll( parameters, os, indent+1 );
                 } // if
         } // if
 …
 std::list< TypeDecl * > * UnionInstType::get_baseParameters() {
         if ( ! baseUnion ) return NULL;
+        if ( ! baseUnion ) return nullptr;
         return &baseUnion->get_parameters();
+}
 …
+}
 void UnionInstType::print( std::ostream &os, int indent ) const {
+void UnionInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
         if ( baseUnion == NULL ) ReferenceToType::print( os, indent );
+        if ( baseUnion == nullptr ) ReferenceToType::print( os, indent );
         else {
                 Type::print( os, indent );
                 os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
                 if ( ! parameters.empty() ) {
                         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                         printAll( parameters, os, indent+2 );
+                        os << endl << indent << "... with parameters" << endl;
+                        printAll( parameters, os, indent+1 );
                 } // if
         } // if
 …
 bool EnumInstType::isComplete() const { return baseEnum ? baseEnum->has_body() : false; }
+void EnumInstType::print( std::ostream &os, Indenter indent ) const {
+        using std::endl;
+        if ( baseEnum == nullptr ) ReferenceToType::print( os, indent );
+        else {
+                Type::print( os, indent );
+                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body() << " ";
+        } // if
+}
 std::string TraitInstType::typeString() const { return "trait"; }
 …
 bool TypeInstType::isComplete() const { return baseType->isComplete(); }
 void TypeInstType::print( std::ostream &os, int indent ) const {
+void TypeInstType::print( std::ostream &os, Indenter indent ) const {
         using std::endl;
 …
         os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
         if ( ! parameters.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
                 printAll( parameters, os, indent+2 );
+                os << endl << indent << "... with parameters" << endl;
+                printAll( parameters, os, indent+1 );
         } // if
+}

src/SynTree/ReferenceType.cc

r78315272	r3f7e12cb
35	35	}
36	36
37		void ReferenceType::print( std::ostream &os, ~~int~~ indent ) const {
	37	void ReferenceType::print( std::ostream &os, Indenter indent ) const {
38	38	Type::print( os, indent );
39	39	os << "reference to ";

src/SynTree/Statement.cc

-              r78315272
+              r3f7e12cb
 Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
+void Statement::print( __attribute__((unused)) std::ostream &, __attribute__((unused)) int indent ) const {}
+void Statement::print( std::ostream & os, Indenter ) const {
+        if ( ! labels.empty() ) {
+                os << "Labels: {";
+                for ( const Label & l : labels ) {
+                        os << l << ",";
+                }
+                os << "}" << endl;
+        }
+}
 Statement::~Statement() {}
 …
+}
 void ExprStmt::print( std::ostream &os, int indent ) const {
         os << "Expression Statement:" << endl << std::string( indent + 2, ' ' );
         expr->print( os, indent + 2 );
+void ExprStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Expression Statement:" << endl << indent+1;
+        expr->print( os, indent+1 );
+}
 …
+}
 void AsmStmt::print( std::ostream &os, int indent ) const {
+void AsmStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Assembler Statement:" << endl;
         os << std::string( indent, ' ' ) << "instruction: " << endl << std::string( indent, ' ' );
         instruction->print( os, indent + 2 );
+        os << indent+1 << "instruction: " << endl << indent;
+        instruction->print( os, indent+1 );
         if ( ! output.empty() ) {
                 os << endl << std::string( indent, ' ' ) << "output: " << endl;
                 printAll( output, os, indent + 2 );
+                os << endl << indent+1 << "output: " << endl;
+                printAll( output, os, indent+1 );
         } // if
         if ( ! input.empty() ) {
                 os << std::string( indent, ' ' ) << "input: " << endl << std::string( indent, ' ' );
                 printAll( input, os, indent + 2 );
+                os << indent+1 << "input: " << endl;
+                printAll( input, os, indent+1 );
         } // if
         if ( ! clobber.empty() ) {
                 os << std::string( indent, ' ' ) << "clobber: " << endl;
                 printAll( clobber, os, indent + 2 );
+                os << indent+1 << "clobber: " << endl;
+                printAll( clobber, os, indent+1 );
         } // if
+}
 …
+}
 void BranchStmt::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' ) << "Branch (" << brType[type] << ")" << endl ;
         if ( target != "" ) os << string( indent+2, ' ' ) << "with target: " << target << endl;
         if ( originalTarget != "" ) os << string( indent+2, ' ' ) << "with original target: " << originalTarget << endl;
         if ( computedTarget != nullptr ) os << string( indent+2, ' ' ) << "with computed target: " << computedTarget << endl;
+void BranchStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Branch (" << brType[type] << ")" << endl ;
+        if ( target != "" ) os << indent+1 << "with target: " << target << endl;
+        if ( originalTarget != "" ) os << indent+1 << "with original target: " << originalTarget << endl;
+        if ( computedTarget != nullptr ) os << indent+1 << "with computed target: " << computedTarget << endl;
+}
 …
+}
 void ReturnStmt::print( std::ostream &os, int indent ) const {
         os <<  "Return Statement, returning: ";
         if ( expr != 0 ) {
                 os << endl << string( indent+2, ' ' );
                 expr->print( os, indent + 2 );
+void ReturnStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "Return Statement, returning: ";
+        if ( expr != nullptr ) {
+                os << endl << indent+1;
+                expr->print( os, indent+1 );
+        }
         os << endl;
 …
+}
 void IfStmt::print( std::ostream &os, int indent ) const {
         os << "If on condition: " << endl ;
         os << string( indent+4, ' ' );
         condition->print( os, indent + 4 );
+void IfStmt::print( std::ostream &os, Indenter indent ) const {
+        os << "If on condition: " << endl;
+        os << indent+1;
+        condition->print( os, indent+1 );
         if ( !initialization.empty() ) {
                 os << string( indent + 2, ' ' ) << "initialization: \n";
                 for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
                         os << string( indent + 4, ' ' );
                         (*it)->print( os, indent + 4 );
+                os << indent << "... with initialization: \n";
+                for ( const Statement * stmt : initialization ) {
+                        os << indent+1;
+                        stmt->print( os, indent+1 );
+                }
                 os << endl;
+        }
         os << string( indent+2, ' ' ) << "... then: " << endl;
         os << string( indent+4, ' ' );
         thenPart->print( os, indent + 4 );
+        os << indent << "... then: " << endl;
+        os << indent+1;
+        thenPart->print( os, indent+1 );
         if ( elsePart != 0 ) {
                 os << string( indent+2, ' ' ) << "... else: " << endl;
                 os << string( indent+4, ' ' );
                 elsePart->print( os, indent + 4 );
         } // if
+}
 SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, std::list<Statement *> &statements ):
+                os << indent << "... else: " << endl;
+                os << indent+1;
+                elsePart->print( os, indent+1 );
+        } // if
+}
+SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
         Statement( labels ), condition( condition ), statements( statements ) {
+}
 …
+}
 void SwitchStmt::print( std::ostream &os, int indent ) const {
+void SwitchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Switch on condition: ";
         condition->print( os );
         os << endl;
+        // statements
+        std::list<Statement *>::const_iterator i;
+        for ( i = statements.begin(); i != statements.end(); i++)
+                (*i)->print( os, indent + 4 );
+        //for_each( statements.begin(), statements.end(), mem_fun( bind1st(&Statement::print ), os ));
+}
+CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+        for ( const Statement * stmt : statements ) {
+                stmt->print( os, indent+1 );
+        }
+}
+CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
         Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
+        if ( isDefault() && condition != 0 )
+                throw SemanticError("default with conditions");
+        if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
+}
 …
+}
+void CaseStmt::print( std::ostream &os, int indent ) const {
+        os << string( indent, ' ' );
+        if ( isDefault() )
+                os << "Default ";
+void CaseStmt::print( std::ostream &os, Indenter indent ) const {
+        if ( isDefault() ) os << "Default ";
         else {
                 os << "Case ";
+                condition->print( os );
+        } // if
+        os << endl;
+        std::list<Statement *>::const_iterator i;
+        for ( i = stmts.begin(); i != stmts.end(); i++)
+                (*i )->print( os, indent + 4 );
+                condition->print( os, indent );
+        } // if
+        os << endl;
+        for ( Statement * stmt : stmts ) {
+                stmt->print( os, indent+1 );
+        }
+}
 …
+}
 void WhileStmt::print( std::ostream &os, int indent ) const {
+void WhileStmt::print( std::ostream &os, Indenter indent ) const {
         os << "While on condition: " << endl ;
         condition->print( os, indent + 4 );
         os << string( indent, ' ' ) << ".... with body: " << endl;
         if ( body != 0 ) body->print( os, indent + 4 );
+        condition->print( os, indent+1 );
+        os << indent << "... with body: " << endl;
+        if ( body != 0 ) body->print( os, indent+1 );
+}
 …
+}
+void ForStmt::print( std::ostream &os, int indent ) const {
+        os << "Labels: {";
+        for ( std::list<Label>::const_iterator it = get_labels().begin(); it != get_labels().end(); ++it) {
+                os << *it << ",";
+        }
+        os << "}" << endl;
+        os << string( indent, ' ' ) << "For Statement" << endl ;
+        os << string( indent + 2, ' ' ) << "initialization: \n";
+        for ( std::list<Statement *>::const_iterator it = initialization.begin(); it != initialization.end(); ++it ) {
+                os << string( indent + 4, ' ' );
+                (*it)->print( os, indent + 4 );
+        }
+        os << "\n" << string( indent + 2, ' ' ) << "condition: \n";
+        if ( condition != 0 ) {
+                os << string( indent + 4, ' ' );
+                condition->print( os, indent + 4 );
+        }
+        os << "\n" << string( indent + 2, ' ' ) << "increment: \n";
+        if ( increment != 0 ) {
+                os << string( indent + 4, ' ' );
+                increment->print( os, indent + 4 );
+        }
+        os << "\n" << string( indent + 2, ' ' ) << "statement block: \n";
+void ForStmt::print( std::ostream &os, Indenter indent ) const {
+        Statement::print( os, indent ); // print labels
+        os << "For Statement" << endl;
+        if ( ! initialization.empty() ) {
+                os << indent << "... initialization: \n";
+                for ( Statement * stmt : initialization ) {
+                        os << indent+1;
+                        stmt->print( os, indent+1 );
+                }
+        }
+        if ( condition != nullptr ) {
+                os << indent << "... condition: \n" << indent+1;
+                condition->print( os, indent+1 );
+        }
+        if ( increment != nullptr ) {
+                os << "\n" << indent << "... increment: \n" << indent+1;
+                increment->print( os, indent+1 );
+        }
         if ( body != 0 ) {
+                os << string( indent + 4, ' ' );
+                body->print( os, indent + 4 );
+        }
+                os << "\n" << indent << "... with body: \n" << indent+1;
+                body->print( os, indent+1 );
+        }
         os << endl;
+}
 …
+}
+void ThrowStmt::print( std::ostream &os, int indent) const {
+void ThrowStmt::print( std::ostream &os, Indenter indent) const {
+        if ( target ) os << "Non-Local ";
+        os << "Throw Statement, raising: ";
+        expr->print(os, indent+1);
         if ( target ) {
+                os << "Non-Local ";
+        }
+        os << "Throw Statement, raising: ";
+        expr->print(os, indent + 4);
+        if ( target ) {
+                os << "At: ";
+                target->print(os, indent + 4);
+                os << "... at: ";
+                target->print(os, indent+1);
+        }
+}
 …
+}
 void TryStmt::print( std::ostream &os, int indent ) const {
+void TryStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Try Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        block->print( os, indent + 4 );
+        os << indent << "... with block:" << endl << indent+1;
+        block->print( os, indent+1 );
         // handlers
         os << string( indent + 2, ' ' ) << "and handlers:" << endl;
         for ( std::list<CatchStmt *>::const_iterator i = handlers.begin(); i != handlers.end(); i++) {
                 os << string( indent + 4, ' ' );
                 (*i )->print( os, indent + 4 );
+        os << indent << "... and handlers:" << endl;
+        for ( const CatchStmt * stmt : handlers ) {
+                os << indent+1;
+                stmt->print( os, indent+1 );
+        }
         // finally block
         if ( finallyBlock != 0 ) {
                 os << string( indent + 2, ' ' ) << "and finally:" << endl;
                 finallyBlock->print( os, indent + 4 );
+                os << indent << "... and finally:" << endl << indent+1;
+                finallyBlock->print( os, indent+1 );
         } // if
+}
 …
 CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
         Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+                assertf( decl, "Catch clause must have a declaration." );
+}
 …
+}
 void CatchStmt::print( std::ostream &os, int indent ) const {
+void CatchStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
+        os << string( indent + 2, ' ' ) << "... catching: ";
+        if ( decl ) {
+                decl->printShort( os, indent + 4 );
+                os << endl;
+        }
+        else
+                os << string( indent + 4 , ' ' ) << ">>> Error:  this catch clause must have a declaration <<<" << endl;
+        os << indent << "... catching: ";
+        decl->printShort( os, indent+1 );
+        os << endl;
         if ( cond ) {
+                os << string( indent + 2, ' ' ) << "with conditional:" << endl;
+                os << string( indent + 4, ' ' );
+                cond->print( os, indent + 4 );
+        }
+        else
+                os << string( indent + 2, ' ' ) << "with no conditional" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        body->print( os, indent + 4 );
+                os << indent << "... with conditional:" << endl << indent+1;
+                cond->print( os, indent+1 );
+        }
+        os << indent << "... with block:" << endl;
+        os << indent+1;
+        body->print( os, indent+1 );
+}
 …
+}
 void FinallyStmt::print( std::ostream &os, int indent ) const {
+void FinallyStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Finally Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        block->print( os, indent + 4 );
+        os << indent << "... with block:" << endl << indent+1;
+        block->print( os, indent+1 );
+}
 …
+}
 void WaitForStmt::print( std::ostream &os, int indent ) const {
+void WaitForStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Waitfor Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with block:" << endl;
+        os << string( indent + 4, ' ' );
+        os << indent << "... with block:" << endl << indent+1;
         // block->print( os, indent + 4 );
+}
 …
 NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
 void NullStmt::print( std::ostream &os, __attribute__((unused)) int indent ) const {
         os << "Null Statement" << endl ;
+void NullStmt::print( std::ostream &os, Indenter ) const {
+        os << "Null Statement" << endl;
+}
 …
+}
 void ImplicitCtorDtorStmt::print( std::ostream &os, int indent ) const {
+void ImplicitCtorDtorStmt::print( std::ostream &os, Indenter indent ) const {
         os << "Implicit Ctor Dtor Statement" << endl;
+        os << string( indent + 2, ' ' ) << "with Ctor/Dtor: ";
+        callStmt->print( os, indent + 2);
+        os << endl;
+}
+std::ostream & operator<<( std::ostream & out, const Statement * statement ) {
+        if ( statement ) {
+                statement->print( out );
+        } else {
+                out << "nullptr";
+        }
+        return out;
+        os << indent << "... with Ctor/Dtor: ";
+        callStmt->print( os, indent+1);
+        os << endl;
+}

src/SynTree/Statement.h

-              r78315272
+              r3f7e12cb
         const std::list<Label> & get_labels() const { return labels; }
         virtual Statement *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
         virtual Statement *acceptMutator( Mutator &m ) = 0;
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual Statement *clone() const override = 0;
+        virtual void accept( Visitor &v ) override = 0;
+        virtual Statement *acceptMutator( Mutator &m ) override = 0;
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         CompoundStmt( std::list<Label> labels );
+        CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt &other );
         virtual ~CompoundStmt();
 …
         void push_front( Statement * stmt ) { kids.push_front( stmt ); }
         virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual CompoundStmt *clone() const override { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual CompoundStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         NullStmt( std::list<Label> labels );
         virtual NullStmt *clone() const { return new NullStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual NullStmt *clone() const override { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ExprStmt *clone() const override { return new ExprStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Statement * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         void set_elsePart( Statement *newValue ) { elsePart = newValue; }
         virtual IfStmt *clone() const { return new IfStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual IfStmt *clone() const override { return new IfStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         std::list<Statement *> statements;
         SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &statements );
+        SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
 …
         std::list<Statement *> & get_statements() { return statements; }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual SwitchStmt *clone() const override { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         std::list<Statement *> stmts;
         CaseStmt( std::list<Label> labels, Expression *conditions, std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
 …
         void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual CaseStmt *clone() const override { return new CaseStmt( *this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         bool _isDefault;
 …
         void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
         virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual WhileStmt *clone() const override { return new WhileStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_body( Statement *newValue ) { body = newValue; }
         virtual ForStmt *clone() const { return new ForStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ForStmt *clone() const override { return new ForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         const char *get_typename() { return brType[ type ]; }
         virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual BranchStmt *clone() const override { return new BranchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
   private:
         static const char *brType[];
 …
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ReturnStmt *clone() const override { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_target( Expression * newTarget ) { target = newTarget; }
         virtual ThrowStmt *clone() const { return new ThrowStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual ThrowStmt *clone() const override { return new ThrowStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
         virtual TryStmt *clone() const { return new TryStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual TryStmt *clone() const override { return new TryStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_body( Statement *newValue ) { body = newValue; }
         virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual CatchStmt *clone() const override { return new CatchStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_block( CompoundStmt *newValue ) { block = newValue; }
         virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual FinallyStmt *clone() const override { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         } orelse;
         virtual WaitForStmt *clone() const { return new WaitForStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual WaitForStmt *clone() const override { return new WaitForStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_decl( Declaration *newValue ) { decl = newValue; }
         virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
         virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
         virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual DeclStmt *clone() const override { return new DeclStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
 };
 …
         void set_callStmt( Statement * newValue ) { callStmt = newValue; }
+        virtual ImplicitCtorDtorStmt *clone() const { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Statement * statement );
+        virtual ImplicitCtorDtorStmt *clone() const override { return new ImplicitCtorDtorStmt( *this ); }
+        virtual void accept( Visitor &v ) override { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream &os, Indenter indent = {} ) const override;
+};
 // Local Variables: //

src/SynTree/TupleExpr.cc

-              r78315272
+              r3f7e12cb
 #include "Type.h"               // for TupleType, Type
 UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+UntypedTupleExpr::UntypedTupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
+}
 …
+}
 void UntypedTupleExpr::print( std::ostream &os, int indent ) const {
+void UntypedTupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Untyped Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
+        printAll( exprs, os, indent+1 );
         Expression::print( os, indent );
+}
 TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
+TupleExpr::TupleExpr( const std::list< Expression * > & exprs ) : Expression(), exprs( exprs ) {
         set_result( Tuples::makeTupleType( exprs ) );
+}
 …
+}
 void TupleExpr::print( std::ostream &os, int indent ) const {
+void TupleExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
+        printAll( exprs, os, indent+1 );
         Expression::print( os, indent );
+}
 …
+}
 void TupleIndexExpr::print( std::ostream &os, int indent ) const {
+void TupleIndexExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple Index Expression, with tuple:" << std::endl;
         os << std::string( indent+2, ' ' );
         tuple->print( os, indent+2 );
         os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
+        os << indent+1;
+        tuple->print( os, indent+1 );
+        os << indent+1 << "with index: " << index << std::endl;
         Expression::print( os, indent );
+}
 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ) {
+TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls ) : Expression() {
         // convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
         set_result( Tuples::makeTupleType( assigns ) );
 …
+}
 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
+void TupleAssignExpr::print( std::ostream &os, Indenter indent ) const {
         os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
         os << std::string( indent+2, ' ' );
         stmtExpr->print( os, indent+4 );
+        os << indent+1;
+        stmtExpr->print( os, indent+1 );
         Expression::print( os, indent );
+}

src/SynTree/TupleType.cc

r78315272	r3f7e12cb
48	48	}
49	49
50		void TupleType::print( std::ostream &os, ~~int~~ indent ) const {
	50	void TupleType::print( std::ostream &os, Indenter indent ) const {
51	51	Type::print( os, indent );
52	52	os << "tuple of types" << std::endl;
53		printAll( types, os, indent+2 );
	53	printAll( types, os, indent+1 );
54	54	}
55	55

src/SynTree/Type.cc

-              r78315272
+              r3f7e12cb
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 11 13:21:25 2017
 // Update Count     : 37
+// Last Modified On : Mon Sep 25 15:16:32 2017
+// Update Count     : 38
 //
 #include "Type.h"
 …
         "double _Imaginary",
         "long double _Imaginary",
+        "__int128",
+        "unsigned __int128",
 };
 …
         Type * type;
         ReferenceType * ref;
         for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->get_base() );
+        for ( type = this; (ref = dynamic_cast<ReferenceType *>( type )); type = ref->base );
         return type;
+}
 …
 int Type::referenceDepth() const { return 0; }
 void Type::print( std::ostream &os, int indent ) const {
+void Type::print( std::ostream &os, Indenter indent ) const {
         if ( ! forall.empty() ) {
                 os << "forall" << std::endl;
                 printAll( forall, os, indent + 4 );
                 os << std::string( indent+2, ' ' );
+                printAll( forall, os, indent+1 );
+                os << ++indent;
         } // if
         if ( ! attributes.empty() ) {
                 os << endl << string( indent+2, ' ' ) << "with attributes" << endl;
                 printAll( attributes, os, indent+4 );
+                os << "with attributes" << endl;
+                printAll( attributes, os, indent+1 );
         } // if
 …
 const Type::Qualifiers noQualifiers;
-std::ostream & operator<<( std::ostream & out, const Type * type ) {
-        if ( type ) {
-                type->print( out );
-        } else {
-                out << "nullptr";
-        } // if
-        return out;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

-              r78315272
+              r3f7e12cb
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Aug  9 14:25:00 2017
 // Update Count     : 152
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Sep 25 14:14:01 2017
+// Update Count     : 154
 //
 …
         virtual void accept( Visitor & v ) = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const;
 };
 …
         VoidType( const Type::Qualifiers & tq, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         virtual unsigned size() const { return 0; };
         virtual bool isComplete() const { return false; }
         virtual VoidType *clone() const { return new VoidType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return 0; };
+        virtual bool isComplete() const override { return false; }
+        virtual VoidType *clone() const override { return new VoidType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
                 DoubleImaginary,
                 LongDoubleImaginary,
+                SignedInt128,
+                UnsignedInt128,
                 NUMBER_OF_BASIC_TYPES
         } kind;
 …
         void set_kind( Kind newValue ) { kind = newValue; }
         virtual BasicType *clone() const { return new BasicType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual BasicType *clone() const override { return new BasicType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         bool isInteger() const;
 …
         bool is_array() const { return isStatic || isVarLen || dimension; }
         virtual bool isComplete() const { return ! isVarLen; }
         virtual PointerType *clone() const { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { return ! isVarLen; }
+        virtual PointerType *clone() const override { return new PointerType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         void set_isStatic( bool newValue ) { isStatic = newValue; }
+        virtual bool isComplete() const { return ! isVarLen; }
+        virtual ArrayType *clone() const { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+        // array types are complete if they have a dimension expression or are
+        // VLAs ('*' in parameter declaration), and incomplete otherwise.
+        // See 6.7.6.2
+        virtual bool isComplete() const override { return dimension || isVarLen; }
+        virtual ArrayType *clone() const override { return new ArrayType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         void set_base( Type *newValue ) { base = newValue; }
         virtual int referenceDepth() const;
+        virtual int referenceDepth() const override;
         // Since reference types act like value types, their size is the size of the base.
         // This makes it simple to cast the empty tuple to a reference type, since casts that increase
         // the number of values are disallowed.
         virtual unsigned size() const { return base->size(); }
         virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual unsigned size() const override { return base->size(); }
+        virtual ReferenceType *clone() const override { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         bool isTtype() const;
         virtual FunctionType *clone() const { return new FunctionType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual FunctionType *clone() const override { return new FunctionType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         void set_hoistType( bool newValue ) { hoistType = newValue; }
         virtual ReferenceToType *clone() const = 0;
         virtual void accept( Visitor & v ) = 0;
         virtual Type *acceptMutator( Mutator & m ) = 0;
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ReferenceToType *clone() const override = 0;
+        virtual void accept( Visitor & v ) override = 0;
+        virtual Type *acceptMutator( Mutator & m ) override = 0;
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
         virtual void lookup( __attribute__((unused)) const std::string & name, __attribute__((unused)) std::list< Declaration* > & foundDecls ) const {}
 …
         std::list<TypeDecl*> * get_baseParameters();
         virtual bool isComplete() const;
+        virtual bool isComplete() const override;
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
         virtual StructInstType *clone() const { return new StructInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+        virtual StructInstType *clone() const override { return new StructInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         std::list< TypeDecl * > * get_baseParameters();
         virtual bool isComplete() const;
+        virtual bool isComplete() const override;
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
         void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const;
         virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        void lookup( const std::string & name, std::list< Declaration* > & foundDecls ) const override;
+        virtual UnionInstType *clone() const override { return new UnionInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         void set_baseEnum( EnumDecl *newValue ) { baseEnum = newValue; }
+        virtual bool isComplete() const;
+        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+        virtual EnumInstType *clone() const override { return new EnumInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         ~TraitInstType();
         virtual bool isComplete() const;
         virtual TraitInstType *clone() const { return new TraitInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual bool isComplete() const override;
+        virtual TraitInstType *clone() const override { return new TraitInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         void set_isFtype( bool newValue ) { isFtype = newValue; }
         virtual bool isComplete() const;
         virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override;
+        virtual TypeInstType *clone() const override { return new TypeInstType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
   private:
         virtual std::string typeString() const;
+        virtual std::string typeString() const override;
 };
 …
         std::list<Type *> & get_types() { return types; }
         virtual unsigned size() const { return types.size(); };
+        virtual unsigned size() const override { return types.size(); };
         // For now, this is entirely synthetic -- tuple types always have unnamed members.
 …
         iterator end() { return types.end(); }
         virtual Type * getComponent( unsigned i ) {
+        virtual Type * getComponent( unsigned i ) override {
                 assertf( i < size(), "TupleType::getComponent: index %d must be less than size %d", i, size() );
                 return *(begin()+i);
+        }
         // virtual bool isComplete() const { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
         virtual TupleType *clone() const { return new TupleType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        // virtual bool isComplete() const override { return true; } // xxx - not sure if this is right, might need to recursively check complete-ness
+        virtual TupleType *clone() const override { return new TupleType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         void set_expr( Expression *newValue ) { expr = newValue; }
         virtual bool isComplete() const { assert( false ); return false; }
         virtual TypeofType *clone() const { return new TypeofType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); return false; }
+        virtual TypeofType *clone() const override { return new TypeofType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         void set_isType( bool newValue ) { isType = newValue; }
         virtual bool isComplete() const { assert( false ); } // xxx - not sure what to do here
         virtual AttrType *clone() const { return new AttrType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override { assert( false ); } // xxx - not sure what to do here
+        virtual AttrType *clone() const override { return new AttrType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual bool isComplete() const{ return true; } // xxx - is this right?
         virtual VarArgsType *clone() const { return new VarArgsType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual bool isComplete() const override{ return true; } // xxx - is this right?
+        virtual VarArgsType *clone() const override { return new VarArgsType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
         virtual ZeroType *clone() const { return new ZeroType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
         virtual void print( std::ostream & os, int indent = 0 ) const;
+        virtual ZeroType *clone() const override { return new ZeroType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
 };
 …
         OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        virtual OneType *clone() const { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
+std::ostream & operator<<( std::ostream & out, const Type * type );
+        virtual OneType *clone() const override { return new OneType( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
 // Local Variables: //

src/SynTree/TypeDecl.cc

-              r78315272
+              r3f7e12cb
 #include "Type.h"            // for Type, Type::StorageClasses
 TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Any || kind == Ttype ), kind( kind ) {
+TypeDecl::TypeDecl( const std::string &name, Type::StorageClasses scs, Type *type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), init( init ), sized( kind == Ttype || sized ), kind( kind ) {
+}
 …
 std::string TypeDecl::typeString() const {
+        static const std::string kindNames[] = { "type", "incomplete type", "function type", "tuple type" };
+        return (kind != Any && isComplete() ? "sized " : "") + kindNames[ kind ];
+        static const std::string kindNames[] = { "object type", "function type", "tuple type" };
+        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "typeString: kindNames is out of sync." );
+        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
+        return (isComplete() ? "sized " : "") + kindNames[ kind ];
+}
 std::string TypeDecl::genTypeString() const {
+        static const std::string kindNames[] = { "otype", "dtype", "ftype", "ttype" };
+        static const std::string kindNames[] = { "dtype", "ftype", "ttype" };
+        assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." );
+        assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." );
         return kindNames[ kind ];
+}
 void TypeDecl::print( std::ostream &os, int indent ) const {
+void TypeDecl::print( std::ostream &os, Indenter indent ) const {
   NamedTypeDecl::print( os, indent );
   if ( init ) {
     os << std::endl << std::string( indent, ' ' ) << "with type initializer: ";
     init->print( os, indent + 2 );
+    os << std::endl << indent << "with type initializer: ";
+    init->print( os, indent + 1 );
+  }
+}

src/SynTree/TypeExpr.cc

r78315272	r3f7e12cb
30	30	}
31	31
32		void TypeExpr::print( std::ostream &os, ~~int~~ indent ) const {
	32	void TypeExpr::print( std::ostream &os, Indenter indent ) const {
33	33	if ( type ) type->print( os, indent );
34	34	Expression::print( os, indent );

src/SynTree/TypeSubstitution.cc

-              r78315272
+              r3f7e12cb
 template< typename TypeClass >
 Type *TypeSubstitution::handleType( TypeClass *type ) {
         BoundVarsType oldBoundVars( boundVars );
+        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
 …
         } // if
         Type *ret = Mutator::mutate( type );
-        boundVars = oldBoundVars;
         return ret;
+}
 …
 template< typename TypeClass >
 Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {
         BoundVarsType oldBoundVars( boundVars );
+        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
 …
         } // if
         Type *ret = Mutator::mutate( type );
-        boundVars = oldBoundVars;
         return ret;
+}
 …
+}
+TypeSubstitution * TypeSubstitution::acceptMutator( Mutator & mutator ) {
+        for ( auto & p : typeEnv ) {
+                p.second = maybeMutate( p.second, mutator );
+        }
+        for ( auto & p : varEnv ) {
+                p.second = maybeMutate( p.second, mutator );
+        }
+        return this;
+}
+void TypeSubstitution::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Types:" << std::endl;
+void TypeSubstitution::print( std::ostream &os, Indenter indent ) const {
+        os << indent << "Types:" << std::endl;
         for ( TypeEnvType::const_iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
                 os << std::string( indent+2, ' ' ) << i->first << " -> ";
                 i->second->print( os, indent+4 );
+                os << indent+1 << i->first << " -> ";
+                i->second->print( os, indent+2 );
                 os << std::endl;
         } // for
         os << std::string( indent, ' ' ) << "Non-types:" << std::endl;
+        os << indent << "Non-types:" << std::endl;
         for ( VarEnvType::const_iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
                 os << std::string( indent+2, ' ' ) << i->first << " -> ";
                 i->second->print( os, indent+4 );
+                os << indent+1 << i->first << " -> ";
+                i->second->print( os, indent+2 );
                 os << std::endl;
         } // for

src/SynTree/TypeSubstitution.h

-              r78315272
+              r3f7e12cb
         void normalize();
         TypeSubstitution * acceptMutator( Mutator & mutator );
+        TypeSubstitution * acceptMutator( Mutator & m ) { return m.mutate( this ); }
         void print( std::ostream &os, int indent = 0 ) const;
+        void print( std::ostream &os, Indenter indent = {} ) const;
         TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
   private:
 …
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
+        friend class Mutator;
+        template<typename pass_type>
+        friend class PassVisitor;
         typedef std::map< std::string, Type* > TypeEnvType;

src/SynTree/TypeofType.cc

-              r78315272
+              r3f7e12cb
 // file "LICENCE" distributed with Cforall.
 //
 // TypeofType.cc --
+// TypeofType.cc --
 //
 // Author           : Richard C. Bilson
 …
+}
 void TypeofType::print( std::ostream &os, int indent ) const {
+void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "type-of expression ";

src/SynTree/VarArgsType.cc

r78315272	r3f7e12cb
25	25	VarArgsType::VarArgsType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
26	26
27		void VarArgsType::print( std::ostream &os, ~~int~~ indent ) const {
	27	void VarArgsType::print( std::ostream &os, Indenter indent ) const {
28	28	Type::print( os, indent );
29	29	os << "builtin var args pack";

src/SynTree/VarExprReplacer.h

-              r78315272
+              r3f7e12cb
 private:
         const DeclMap & declMap;
   bool debug;
+        bool debug;
 public:
         VarExprReplacer( const DeclMap & declMap, bool debug = false );
 …
         // replace variable with new node from decl map
         virtual void visit( VariableExpr * varExpr );
+        static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) {
+                VarExprReplacer replacer( declMap, debug );
+                maybeAccept( node, replacer );
+        }
 };

src/SynTree/Visitor.cc

-              r78315272
+              r3f7e12cb
 #include <list>           // for list
+#include "Attribute.h"    // for Attribute
 #include "Constant.h"     // for Constant
 #include "Declaration.h"  // for DeclarationWithType, ObjectDecl, Declaration
 …
         maybeAccept( objectDecl->get_init(), *this );
         maybeAccept( objectDecl->get_bitfieldWidth(), *this );
+        acceptAll( objectDecl->attributes, *this );
+}
 …
         maybeAccept( functionDecl->get_functionType(), *this );
         maybeAccept( functionDecl->get_statements(), *this );
+        acceptAll( functionDecl->attributes, *this );
+}
 …
+void Visitor::visit( __attribute__((unused)) Subrange *subrange ) {}
+void Visitor::visit( __attribute__((unused)) Constant *constant ) {}
+void Visitor::visit( Subrange * ) {}
+void Visitor::visit( Constant * ) {}
+void Visitor::visit( Attribute * attribute ) {
+        acceptAll( attribute->parameters, *this );
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.h

-              r78315272
+              r3f7e12cb
   public:
         // visit: Default implementation of all functions visits the children
     // of the given syntax node, but performs no other action.
+        // of the given syntax node, but performs no other action.
         virtual void visit( ObjectDecl *objectDecl );
         virtual void visit( FunctionDecl *functionDecl );
         virtual void visit( StructDecl *aggregateDecl );
         virtual void visit( UnionDecl *aggregateDecl );
         virtual void visit( EnumDecl *aggregateDecl );
         virtual void visit( TraitDecl *aggregateDecl );
         virtual void visit( TypeDecl *typeDecl );
         virtual void visit( TypedefDecl *typeDecl );
         virtual void visit( AsmDecl *asmDecl );
+        virtual void visit( ObjectDecl * objectDecl );
+        virtual void visit( FunctionDecl * functionDecl );
+        virtual void visit( StructDecl * aggregateDecl );
+        virtual void visit( UnionDecl * aggregateDecl );
+        virtual void visit( EnumDecl * aggregateDecl );
+        virtual void visit( TraitDecl * aggregateDecl );
+        virtual void visit( TypeDecl * typeDecl );
+        virtual void visit( TypedefDecl * typeDecl );
+        virtual void visit( AsmDecl * asmDecl );
         virtual void visit( CompoundStmt *compoundStmt );
         virtual void visit( ExprStmt *exprStmt );
         virtual void visit( AsmStmt *asmStmt );
         virtual void visit( IfStmt *ifStmt );
         virtual void visit( WhileStmt *whileStmt );
         virtual void visit( ForStmt *forStmt );
         virtual void visit( SwitchStmt *switchStmt );
         virtual void visit( CaseStmt *caseStmt );
         virtual void visit( BranchStmt *branchStmt );
         virtual void visit( ReturnStmt *returnStmt );
         virtual void visit( ThrowStmt *throwStmt );
         virtual void visit( TryStmt *tryStmt );
         virtual void visit( CatchStmt *catchStmt );
         virtual void visit( FinallyStmt *finallyStmt );
         virtual void visit( WaitForStmt *waitforStmt );
         virtual void visit( NullStmt *nullStmt );
         virtual void visit( DeclStmt *declStmt );
         virtual void visit( ImplicitCtorDtorStmt *impCtorDtorStmt );
+        virtual void visit( CompoundStmt * compoundStmt );
+        virtual void visit( ExprStmt * exprStmt );
+        virtual void visit( AsmStmt * asmStmt );
+        virtual void visit( IfStmt * ifStmt );
+        virtual void visit( WhileStmt * whileStmt );
+        virtual void visit( ForStmt * forStmt );
+        virtual void visit( SwitchStmt * switchStmt );
+        virtual void visit( CaseStmt * caseStmt );
+        virtual void visit( BranchStmt * branchStmt );
+        virtual void visit( ReturnStmt * returnStmt );
+        virtual void visit( ThrowStmt * throwStmt );
+        virtual void visit( TryStmt * tryStmt );
+        virtual void visit( CatchStmt * catchStmt );
+        virtual void visit( FinallyStmt * finallyStmt );
+        virtual void visit( WaitForStmt * waitforStmt );
+        virtual void visit( NullStmt * nullStmt );
+        virtual void visit( DeclStmt * declStmt );
+        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
         virtual void visit( ApplicationExpr *applicationExpr );
         virtual void visit( UntypedExpr *untypedExpr );
         virtual void visit( NameExpr *nameExpr );
         virtual void visit( CastExpr *castExpr );
         virtual void visit( VirtualCastExpr *castExpr );
         virtual void visit( AddressExpr *addressExpr );
         virtual void visit( LabelAddressExpr *labAddressExpr );
         virtual void visit( UntypedMemberExpr *memberExpr );
         virtual void visit( MemberExpr *memberExpr );
         virtual void visit( VariableExpr *variableExpr );
         virtual void visit( ConstantExpr *constantExpr );
         virtual void visit( SizeofExpr *sizeofExpr );
         virtual void visit( AlignofExpr *alignofExpr );
         virtual void visit( UntypedOffsetofExpr *offsetofExpr );
         virtual void visit( OffsetofExpr *offsetofExpr );
         virtual void visit( OffsetPackExpr *offsetPackExpr );
         virtual void visit( AttrExpr *attrExpr );
         virtual void visit( LogicalExpr *logicalExpr );
         virtual void visit( ConditionalExpr *conditionalExpr );
         virtual void visit( CommaExpr *commaExpr );
         virtual void visit( TypeExpr *typeExpr );
         virtual void visit( AsmExpr *asmExpr );
         virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
         virtual void visit( ConstructorExpr * ctorExpr );
         virtual void visit( CompoundLiteralExpr *compLitExpr );
         virtual void visit( RangeExpr *rangeExpr );
         virtual void visit( UntypedTupleExpr *tupleExpr );
         virtual void visit( TupleExpr *tupleExpr );
         virtual void visit( TupleIndexExpr *tupleExpr );
         virtual void visit( TupleAssignExpr *assignExpr );
         virtual void visit( StmtExpr * stmtExpr );
         virtual void visit( UniqueExpr * uniqueExpr );
         virtual void visit( UntypedInitExpr * initExpr );
         virtual void visit( InitExpr * initExpr );
+        virtual void visit( ApplicationExpr * applicationExpr );
+        virtual void visit( UntypedExpr * untypedExpr );
+        virtual void visit( NameExpr * nameExpr );
+        virtual void visit( CastExpr * castExpr );
+        virtual void visit( VirtualCastExpr * castExpr );
+        virtual void visit( AddressExpr * addressExpr );
+        virtual void visit( LabelAddressExpr * labAddressExpr );
+        virtual void visit( UntypedMemberExpr * memberExpr );
+        virtual void visit( MemberExpr * memberExpr );
+        virtual void visit( VariableExpr * variableExpr );
+        virtual void visit( ConstantExpr * constantExpr );
+        virtual void visit( SizeofExpr * sizeofExpr );
+        virtual void visit( AlignofExpr * alignofExpr );
+        virtual void visit( UntypedOffsetofExpr * offsetofExpr );
+        virtual void visit( OffsetofExpr * offsetofExpr );
+        virtual void visit( OffsetPackExpr * offsetPackExpr );
+        virtual void visit( AttrExpr * attrExpr );
+        virtual void visit( LogicalExpr * logicalExpr );
+        virtual void visit( ConditionalExpr * conditionalExpr );
+        virtual void visit( CommaExpr * commaExpr );
+        virtual void visit( TypeExpr * typeExpr );
+        virtual void visit( AsmExpr * asmExpr );
+        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
+        virtual void visit( ConstructorExpr *  ctorExpr );
+        virtual void visit( CompoundLiteralExpr * compLitExpr );
+        virtual void visit( RangeExpr * rangeExpr );
+        virtual void visit( UntypedTupleExpr * tupleExpr );
+        virtual void visit( TupleExpr * tupleExpr );
+        virtual void visit( TupleIndexExpr * tupleExpr );
+        virtual void visit( TupleAssignExpr * assignExpr );
+        virtual void visit( StmtExpr *  stmtExpr );
+        virtual void visit( UniqueExpr *  uniqueExpr );
+        virtual void visit( UntypedInitExpr *  initExpr );
+        virtual void visit( InitExpr *  initExpr );
         virtual void visit( VoidType *basicType );
         virtual void visit( BasicType *basicType );
         virtual void visit( PointerType *pointerType );
         virtual void visit( ArrayType *arrayType );
         virtual void visit( ReferenceType *refType );
         virtual void visit( FunctionType *functionType );
         virtual void visit( StructInstType *aggregateUseType );
         virtual void visit( UnionInstType *aggregateUseType );
         virtual void visit( EnumInstType *aggregateUseType );
         virtual void visit( TraitInstType *aggregateUseType );
         virtual void visit( TypeInstType *aggregateUseType );
         virtual void visit( TupleType *tupleType );
         virtual void visit( TypeofType *typeofType );
         virtual void visit( AttrType *attrType );
         virtual void visit( VarArgsType *varArgsType );
         virtual void visit( ZeroType *zeroType );
         virtual void visit( OneType *oneType );
+        virtual void visit( VoidType * basicType );
+        virtual void visit( BasicType * basicType );
+        virtual void visit( PointerType * pointerType );
+        virtual void visit( ArrayType * arrayType );
+        virtual void visit( ReferenceType * refType );
+        virtual void visit( FunctionType * functionType );
+        virtual void visit( StructInstType * aggregateUseType );
+        virtual void visit( UnionInstType * aggregateUseType );
+        virtual void visit( EnumInstType * aggregateUseType );
+        virtual void visit( TraitInstType * aggregateUseType );
+        virtual void visit( TypeInstType * aggregateUseType );
+        virtual void visit( TupleType * tupleType );
+        virtual void visit( TypeofType * typeofType );
+        virtual void visit( AttrType * attrType );
+        virtual void visit( VarArgsType * varArgsType );
+        virtual void visit( ZeroType * zeroType );
+        virtual void visit( OneType * oneType );
         virtual void visit( Designation *designation );
         virtual void visit( SingleInit *singleInit );
         virtual void visit( ListInit *listInit );
         virtual void visit( ConstructorInit *ctorInit );
+        virtual void visit( Designation * designation );
+        virtual void visit( SingleInit * singleInit );
+        virtual void visit( ListInit * listInit );
+        virtual void visit( ConstructorInit * ctorInit );
         virtual void visit( Subrange *subrange );
+        virtual void visit( Subrange * subrange );
+        virtual void visit( Constant *constant );
+        virtual void visit( Constant * constant );
+        virtual void visit( Attribute * attribute );
   private:
         virtual void handleAggregateDecl( AggregateDecl *aggregateDecl );

src/SynTree/VoidType.cc

-              r78315272
+              r3f7e12cb
 // file "LICENCE" distributed with Cforall.
 //
 // VoidType.cc --
+// VoidType.cc --
 //
 // Author           : Richard C. Bilson
 …
+}
 void VoidType::print( std::ostream &os, int indent ) const {
+void VoidType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
         os << "void ";

src/SynTree/ZeroOneType.cc

-              r78315272
+              r3f7e12cb
 ZeroType::ZeroType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 void ZeroType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void ZeroType::print( std::ostream &os, Indenter ) const {
         os << "zero_t";
+}
 …
 OneType::OneType( Type::Qualifiers tq, const std::list< Attribute * > & attributes ) : Type( tq, attributes ) {}
 void OneType::print( std::ostream &os, __attribute__((unused)) int indent ) const {
+void OneType::print( std::ostream &os, Indenter ) const {
         os << "one_t";
+}

src/SynTree/module.mk

r78315272	r3f7e12cb
48	48	SynTree/Visitor.cc \
49	49	SynTree/Mutator.cc \
50		~~SynTree/AddStmtVisitor.cc \~~
51	50	SynTree/TypeSubstitution.cc \
52	51	SynTree/Attribute.cc \

src/Tuples/TupleAssignment.cc

-              r78315272
+              r3f7e12cb
         bool isTuple( Expression *expr ) {
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
+                assert( expr->result );
                 return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
+        }
 …
         ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
+                assert( expr->result && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
                 // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
 …
                         ctorInit->accept( rm );
+                }
+                PRINT( std::cerr << "new object: " << ret << std::endl; )
                 return ret;
+        }

src/Tuples/TupleExpansion.cc

-              r78315272
+              r3f7e12cb
 #include "Common/ScopedMap.h"     // for ScopedMap
 #include "Common/utility.h"       // for CodeLocation
-#include "GenPoly/DeclMutator.h"  // for DeclMutator
 #include "InitTweak/InitTweak.h"  // for getFunction
 #include "Parser/LinkageSpec.h"   // for Spec, C, Intrinsic
 …
                         decl->set_body( true );
                         for ( size_t i = 0; i < tupleSize; ++i ) {
                                 TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", tupleSize, "_", i ), Type::StorageClasses(), nullptr, TypeDecl::Any );
+                                TypeDecl * tyParam = new TypeDecl( toString( "tuple_param_", tupleSize, "_", i ), Type::StorageClasses(), nullptr, TypeDecl::Dtype, true );
                                 decl->get_members().push_back( new ObjectDecl( toString("field_", i ), Type::StorageClasses(), LinkageSpec::C, nullptr, new TypeInstType( Type::Qualifiers(), tyParam->get_name(), tyParam ), nullptr ) );
                                 decl->get_parameters().push_back( tyParam );

src/benchmark/Makefile.am

-              r78315272
+              r3f7e12cb
 AM_CFLAGS = -g -Wall -Wno-unused-function -O2
 CC = @CFA_BINDIR@/@CFA_NAME@
+TOOLSDIR = ${abs_top_srcdir}/tools/
+REPEAT   = ${TOOLSDIR}repeat
+STATS    = ${TOOLSDIR}stat.py
+repeats  = 30
+noinst_PROGRAMS = bench$(EXEEXT) ctxswitch-coroutine$(EXEEXT) ctxswitch-thread$(EXEEXT) sched-int$(EXEEXT) monitor$(EXEEXT) csv-data$(EXEEXT)
+.NOTPARALLEL:
+noinst_PROGRAMS =
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 bench$(EXEEXT) :
 …
         rm -f ./a.out ;
-ctxswitch-coroutine$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 CorCtxSwitch.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
-ctxswitch-thread$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 ThrdCtxSwitch.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
-sched-int$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
-monitor$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 Monitor.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
 csv-data$(EXEEXT):
         @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=50000000 csv-data.c
         @./a.out
         @rm -f ./a.out
+## =========================================================================================================
+ctxswitch$(EXEEXT): \
+        ctxswitch-pthread.run           \
+        ctxswitch-cfa_coroutine.run     \
+        ctxswitch-cfa_thread.run        \
+        ctxswitch-upp_coroutine.run     \
+        ctxswitch-upp_thread.run
+ctxswitch-cfa_coroutine$(EXEEXT):
+        ${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-cfa_thread$(EXEEXT):
+        ${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_coroutine$(EXEEXT):
+        u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_thread$(EXEEXT):
+        u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-pthread$(EXEEXT):
+        @BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+mutex$(EXEEXT) :\
+        mutex-function.run      \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
+        mutex-cfa1.run          \
+        mutex-cfa2.run          \
+        mutex-cfa4.run
+mutex-function$(EXEEXT):
+        @BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-pthread_lock$(EXEEXT):
+        @BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-upp$(EXEEXT):
+        u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa1$(EXEEXT):
+        ${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa2$(EXEEXT):
+        ${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa4$(EXEEXT):
+        ${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+signal$(EXEEXT) :\
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run
+signal-upp$(EXEEXT):
+        u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa1$(EXEEXT):
+        ${CC}        schedint/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa2$(EXEEXT):
+        ${CC}        schedint/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa4$(EXEEXT):
+        ${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        u++          schedext/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa1$(EXEEXT):
+        ${CC}        schedext/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa2$(EXEEXT):
+        ${CC}        schedext/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa4$(EXEEXT):
+        ${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+creation$(EXEEXT) :\
+        creation-pthread.run            \
+        creation-cfa_coroutine.run      \
+        creation-cfa_thread.run         \
+        creation-upp_coroutine.run      \
+        creation-upp_thread.run
+creation-cfa_coroutine$(EXEEXT):
+        ${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-cfa_thread$(EXEEXT):
+        ${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_coroutine$(EXEEXT):
+        u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_thread$(EXEEXT):
+        u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-pthread$(EXEEXT):
+        @BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+## =========================================================================================================
+%.run : %$(EXEEXT) ${REPEAT}
+        @rm -f .result.log
+        @echo "------------------------------------------------------"
+        @echo $<
+        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
+        @${STATS} .result.log
+        @echo "------------------------------------------------------"
+        @rm -f a.out .result.log
+${REPEAT} :
+        @+make -C ${TOOLSDIR} repeat

src/benchmark/Makefile.in

-              r78315272
+              r3f7e12cb
 build_triplet = @build@
 host_triplet = @host@
+noinst_PROGRAMS =
 subdir = src/benchmark
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 …
 CONFIG_CLEAN_VPATH_FILES =
 PROGRAMS = $(noinst_PROGRAMS)
-bench_SOURCES = bench.c
-bench_OBJECTS = bench.$(OBJEXT)
-bench_LDADD = $(LDADD)
-csv_data_SOURCES = csv-data.c
-csv_data_OBJECTS = csv-data.$(OBJEXT)
-csv_data_LDADD = $(LDADD)
-ctxswitch_coroutine_SOURCES = ctxswitch-coroutine.c
-ctxswitch_coroutine_OBJECTS = ctxswitch-coroutine.$(OBJEXT)
-ctxswitch_coroutine_LDADD = $(LDADD)
-ctxswitch_thread_SOURCES = ctxswitch-thread.c
-ctxswitch_thread_OBJECTS = ctxswitch-thread.$(OBJEXT)
-ctxswitch_thread_LDADD = $(LDADD)
-monitor_SOURCES = monitor.c
-monitor_OBJECTS = monitor.$(OBJEXT)
-monitor_LDADD = $(LDADD)
-sched_int_SOURCES = sched-int.c
-sched_int_OBJECTS = sched-int.$(OBJEXT)
-sched_int_LDADD = $(LDADD)
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 …
 am__v_at_0 = @
 am__v_at_1 =
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/automake/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+        $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC      " $@;
+am__v_CC_1 =
+CCLD = $(CC)
+LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD    " $@;
+am__v_CCLD_1 =
+SOURCES = bench.c csv-data.c ctxswitch-coroutine.c ctxswitch-thread.c \
+        monitor.c sched-int.c
+DIST_SOURCES = bench.c csv-data.c ctxswitch-coroutine.c \
+        ctxswitch-thread.c monitor.c sched-int.c
+SOURCES =
+DIST_SOURCES =
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
 …
   esac
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
+# Read a list of newline-separated strings from the standard input,
+# and print each of them once, without duplicates.  Input order is
+# *not* preserved.
+am__uniquify_input = $(AWK) '\
+  BEGIN { nonempty = 0; } \
+  { items[$$0] = 1; nonempty = 1; } \
+  END { if (nonempty) { for (i in items) print i; }; } \
+'
+# Make sure the list of sources is unique.  This is necessary because,
+# e.g., the same source file might be shared among _SOURCES variables
+# for different programs/libraries.
+am__define_uniq_tagged_files = \
+  list='$(am__tagged_files)'; \
+  unique=`for i in $$list; do \
+    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+  done | $(am__uniquify_input)`
+ETAGS = etags
+CTAGS = ctags
+am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/automake/depcomp
+am__DIST_COMMON = $(srcdir)/Makefile.in
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 …
 top_srcdir = @top_srcdir@
 AM_CFLAGS = -g -Wall -Wno-unused-function -O2
+noinst_PROGRAMS = bench$(EXEEXT) ctxswitch-coroutine$(EXEEXT) ctxswitch-thread$(EXEEXT) sched-int$(EXEEXT) monitor$(EXEEXT) csv-data$(EXEEXT)
+TOOLSDIR = ${abs_top_srcdir}/tools/
+REPEAT = ${TOOLSDIR}repeat
+STATS = ${TOOLSDIR}stat.py
+repeats = 30
 all: all-am
 .SUFFIXES:
-.SUFFIXES: .c .o .obj
 $(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
         @for dep in $?; do \
 …
 clean-noinstPROGRAMS:
         -test -z "$(noinst_PROGRAMS)" || rm -f $(noinst_PROGRAMS)
+mostlyclean-compile:
+        -rm -f *.$(OBJEXT)
+distclean-compile:
+        -rm -f *.tab.c
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bench.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/csv-data.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ctxswitch-coroutine.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ctxswitch-thread.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/monitor.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/sched-int.Po@am__quote@
+.c.o:
+@am__fastdepCC_TRUE@    $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCC_TRUE@    $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCC_TRUE@    $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
+.c.obj:
+@am__fastdepCC_TRUE@    $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCC_TRUE@    $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCC_TRUE@    $(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+ID: $(am__tagged_files)
+        $(am__define_uniq_tagged_files); mkid -fID $$unique
+tags: tags-am
+TAGS: tags
+tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+        set x; \
+        here=`pwd`; \
+        $(am__define_uniq_tagged_files); \
+        shift; \
+        if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+          test -n "$$unique" || unique=$$empty_fix; \
+          if test $$# -gt 0; then \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              "$$@" $$unique; \
+          else \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              $$unique; \
+          fi; \
+        fi
+ctags: ctags-am
+CTAGS: ctags
+ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
+        $(am__define_uniq_tagged_files); \
+        test -z "$(CTAGS_ARGS)$$unique" \
+          || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+             $$unique
+GTAGS:
+        here=`$(am__cd) $(top_builddir) && pwd` \
+          && $(am__cd) $(top_srcdir) \
+          && gtags -i $(GTAGS_ARGS) "$$here"
+cscopelist: cscopelist-am
+cscopelist-am: $(am__tagged_files)
+        list='$(am__tagged_files)'; \
+        case "$(srcdir)" in \
+          [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
+          *) sdir=$(subdir)/$(srcdir) ;; \
+        esac; \
+        for i in $$list; do \
+          if test -f "$$i"; then \
+            echo "$(subdir)/$$i"; \
+          else \
+            echo "$$sdir/$$i"; \
+          fi; \
+        done >> $(top_builddir)/cscope.files
+distclean-tags:
+        -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+tags TAGS:
+ctags CTAGS:
+cscope cscopelist:
 distdir: $(DISTFILES)
 …
 distclean: distclean-am
-        -rm -rf ./$(DEPDIR)
         -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+        distclean-tags
+distclean-am: clean-am distclean-generic
 dvi: dvi-am
 …
 maintainer-clean: maintainer-clean-am
-        -rm -rf ./$(DEPDIR)
         -rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 …
 mostlyclean: mostlyclean-am
 mostlyclean-am: mostlyclean-compile mostlyclean-generic
+mostlyclean-am: mostlyclean-generic
 pdf: pdf-am
 …
 .MAKE: install-am install-strip
+.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
+        clean-noinstPROGRAMS cscopelist-am ctags ctags-am distclean \
+        distclean-compile distclean-generic distclean-tags distdir dvi \
+        dvi-am html html-am info info-am install install-am \
+        install-data install-data-am install-dvi install-dvi-am \
+        install-exec install-exec-am install-html install-html-am \
+        install-info install-info-am install-man install-pdf \
+        install-pdf-am install-ps install-ps-am install-strip \
+        installcheck installcheck-am installdirs maintainer-clean \
+        maintainer-clean-generic mostlyclean mostlyclean-compile \
+        mostlyclean-generic pdf pdf-am ps ps-am tags tags-am uninstall \
+.PHONY: all all-am check check-am clean clean-generic \
+        clean-noinstPROGRAMS cscopelist-am ctags-am distclean \
+        distclean-generic distdir dvi dvi-am html html-am info info-am \
+        install install-am install-data install-data-am install-dvi \
+        install-dvi-am install-exec install-exec-am install-html \
+        install-html-am install-info install-info-am install-man \
+        install-pdf install-pdf-am install-ps install-ps-am \
+        install-strip installcheck installcheck-am installdirs \
+        maintainer-clean maintainer-clean-generic mostlyclean \
+        mostlyclean-generic pdf pdf-am ps ps-am tags-am uninstall \
         uninstall-am
 .PRECIOUS: Makefile
+.NOTPARALLEL:
+all : ctxswitch$(EXEEXT) mutex$(EXEEXT) signal$(EXEEXT) waitfor$(EXEEXT) creation$(EXEEXT)
 bench$(EXEEXT) :
 …
         rm -f ./a.out ;
-ctxswitch-coroutine$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 CorCtxSwitch.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
-ctxswitch-thread$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 ThrdCtxSwitch.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
-sched-int$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 SchedInt.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
-monitor$(EXEEXT):
-        ${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -DN=50000000 Monitor.c
-        @rm -f .result.log
-        @for number in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20; do \
-                ./a.out | tee -a .result.log ; \
-        done
-        @./stat.py .result.log
-        @rm -f a.out .result.log
 csv-data$(EXEEXT):
         @${CC} ${AM_CFLAGS} ${CFLAGS} ${ccflags} @CFA_FLAGS@ -nodebug -lrt -quiet -DN=50000000 csv-data.c
 …
         @rm -f ./a.out
+ctxswitch$(EXEEXT): \
+        ctxswitch-pthread.run           \
+        ctxswitch-cfa_coroutine.run     \
+        ctxswitch-cfa_thread.run        \
+        ctxswitch-upp_coroutine.run     \
+        ctxswitch-upp_thread.run
+ctxswitch-cfa_coroutine$(EXEEXT):
+        ${CC}        ctxswitch/cfa_cor.c   -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-cfa_thread$(EXEEXT):
+        ${CC}        ctxswitch/cfa_thrd.c  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_coroutine$(EXEEXT):
+        u++          ctxswitch/upp_cor.cc  -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-upp_thread$(EXEEXT):
+        u++          ctxswitch/upp_thrd.cc -DBENCH_N=50000000  -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+ctxswitch-pthread$(EXEEXT):
+        @BACKEND_CC@ ctxswitch/pthreads.c  -DBENCH_N=50000000  -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex$(EXEEXT) :\
+        mutex-function.run      \
+        mutex-pthread_lock.run  \
+        mutex-upp.run           \
+        mutex-cfa1.run          \
+        mutex-cfa2.run          \
+        mutex-cfa4.run
+mutex-function$(EXEEXT):
+        @BACKEND_CC@ mutex/function.c    -DBENCH_N=500000000   -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-pthread_lock$(EXEEXT):
+        @BACKEND_CC@ mutex/pthreads.c    -DBENCH_N=50000000    -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-upp$(EXEEXT):
+        u++          mutex/upp.cc        -DBENCH_N=50000000    -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa1$(EXEEXT):
+        ${CC}        mutex/cfa1.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa2$(EXEEXT):
+        ${CC}        mutex/cfa2.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+mutex-cfa4$(EXEEXT):
+        ${CC}        mutex/cfa4.c        -DBENCH_N=5000000     -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal$(EXEEXT) :\
+        signal-upp.run          \
+        signal-cfa1.run         \
+        signal-cfa2.run         \
+        signal-cfa4.run
+signal-upp$(EXEEXT):
+        u++          schedint/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa1$(EXEEXT):
+        ${CC}        schedint/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa2$(EXEEXT):
+        ${CC}        schedint/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+signal-cfa4$(EXEEXT):
+        ${CC}        schedint/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor$(EXEEXT) :\
+        waitfor-upp.run         \
+        waitfor-cfa1.run                \
+        waitfor-cfa2.run                \
+        waitfor-cfa4.run
+waitfor-upp$(EXEEXT):
+        u++          schedext/upp.cc     -DBENCH_N=5000000     -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa1$(EXEEXT):
+        ${CC}        schedext/cfa1.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa2$(EXEEXT):
+        ${CC}        schedext/cfa2.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+waitfor-cfa4$(EXEEXT):
+        ${CC}        schedext/cfa4.c     -DBENCH_N=500000      -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation$(EXEEXT) :\
+        creation-pthread.run            \
+        creation-cfa_coroutine.run      \
+        creation-cfa_thread.run         \
+        creation-upp_coroutine.run      \
+        creation-upp_thread.run
+creation-cfa_coroutine$(EXEEXT):
+        ${CC}        creation/cfa_cor.c   -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-cfa_thread$(EXEEXT):
+        ${CC}        creation/cfa_thrd.c  -DBENCH_N=10000000   -I. -nodebug -lrt -quiet @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_coroutine$(EXEEXT):
+        u++          creation/upp_cor.cc  -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-upp_thread$(EXEEXT):
+        u++          creation/upp_thrd.cc -DBENCH_N=50000000   -I. -nodebug -lrt -quiet             ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+creation-pthread$(EXEEXT):
+        @BACKEND_CC@ creation/pthreads.c  -DBENCH_N=250000     -I. -lrt -pthread                    ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+%.run : %$(EXEEXT) ${REPEAT}
+        @rm -f .result.log
+        @echo "------------------------------------------------------"
+        @echo $<
+        @${REPEAT} ${repeats} ./a.out | tee -a .result.log
+        @${STATS} .result.log
+        @echo "------------------------------------------------------"
+        @rm -f a.out .result.log
+${REPEAT} :
+        @+make -C ${TOOLSDIR} repeat
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.

src/benchmark/bench.h

-              r78315272
+              r3f7e12cb
 #pragma once
+#if defined(__CFORALL__)
 extern "C" {
+#endif
+        #include <stdlib.h>
         #include <unistd.h>                                     // sysconf
         #include <sys/times.h>                                  // times
         #include <time.h>
+#if defined(__CFORALL__)
+}
+#endif
 inline unsigned long long int Time() {
     timespec ts;
+static inline unsigned long long int Time() {
+    struct timespec ts;
     clock_gettime(
 #if defined( __linux__ )
 …
 } // Time
 #ifndef N
 #define N 10000000
+#ifndef BENCH_N
+#define BENCH_N 500 //10000000
 #endif
+#define BENCH(statement, output)                \
+        size_t n = BENCH_N;                     \
+        if( argc > 2 ) return 1;                \
+        if( argc == 2 ) {                               \
+                n = atoi(argv[1]);              \
+        }                                               \
+        long long int StartTime, EndTime;       \
+        StartTime = Time();                     \
+        statement;                                      \
+        EndTime = Time();                               \
+        unsigned long long int output =         \
+        ( EndTime - StartTime ) / n;
 unsigned int default_preemption() {

src/benchmark/csv-data.c

-              r78315272
+              r3f7e12cb
         StartTime = Time();
         for( int i = 0;; i++ ) {
                 signal(&cond1a);
                 if( i > N ) break;
                 wait(&cond1b);
+                signal(cond1a);
+                if( i > N ) break;
+                wait(cond1b);
+        }
         EndTime = Time();
 …
 void side1B( mon_t & mutex a ) {
         for( int i = 0;; i++ ) {
                 signal(&cond1b);
                 if( i > N ) break;
                 wait(&cond1a);
+                signal(cond1b);
+                if( i > N ) break;
+                wait(cond1a);
+        }
+}
 …
         StartTime = Time();
         for( int i = 0;; i++ ) {
                 signal(&cond2a);
                 if( i > N ) break;
                 wait(&cond2b);
+                signal(cond2a);
+                if( i > N ) break;
+                wait(cond2b);
+        }
         EndTime = Time();
 …
 void side2B( mon_t & mutex a, mon_t & mutex b ) {
         for( int i = 0;; i++ ) {
                 signal(&cond2b);
                 if( i > N ) break;
                 wait(&cond2a);
+                signal(cond2b);
+                if( i > N ) break;
+                wait(cond2a);
+        }
+}

src/driver/cfa.cc

-              r78315272
+              r3f7e12cb
 // Author           : Peter A. Buhr
 // Created On       : Tue Aug 20 13:44:49 2002
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Aug 17 15:24:00 2017
 // Update Count     : 156
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Oct 31 11:40:44 2017
+// Update Count     : 160
 //
 …
         } // if
+        shuffle( args, sargs, nargs, 1 );                                       // make room at front of argument list
+        nargs += 1;
         if ( CFA_flag ) {
+                args[sargs] = "-D__CFA_FLAG__=-N";
                 args[nargs] = "-D__CFA_PREPROCESS_";
                 nargs += 1;
+        } // if
+        } else {
+                args[sargs] = "-D__CFA_FLAG__=-L";
+        } // if
+        sargs += 1;
         if ( debug ) {
 …
                 } // if
                 args[nargs] = "-fgnu89-inline";
+                nargs += 1;
+                args[nargs] = "-D__int8_t_defined";                             // prevent gcc type-size attributes
                 nargs += 1;
                 args[nargs] = ( *new string( string("-B") + Bprefix + "/" ) ).c_str();

src/include/cassert

r78315272	r3f7e12cb
41	41	static inline T strict_dynamic_cast( const U & src ) {
42	42	T ret = dynamic_cast<T>(src);
43		assert~~(ret~~);
	43	assertf(ret, "%s", toString(src).c_str());
44	44	return ret;
45	45	}

src/libcfa/Makefile.am

-              r78315272
+              r3f7e12cb
 libcfa_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -Wall -O2 -c -o $@ $<
 libcfa_d_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -Wall -O0 -c -o $@ $<
 EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
+EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
 AM_CCASFLAGS = @CFA_FLAGS@

src/libcfa/Makefile.in

-              r78315272
+              r3f7e12cb
 ARFLAGS = cr
 lib_LIBRARIES = $(am__append_1) $(am__append_2)
 EXTRA_FLAGS = -g -Wall -Werror -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
+EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
 AM_CCASFLAGS = @CFA_FLAGS@
 headers = fstream iostream iterator limits rational stdlib \
 …
 libcfa_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -O2 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -Wall -O2 -c -o $@ $<
 libcfa_d_a-libcfa-prelude.o : libcfa-prelude.c
          ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
+         ${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -Wall -O0 -c -o $@ $<
 # extensionless header files are overridden by -o flag in default makerule => explicitly override default rule to silently do nothing

src/libcfa/concurrency/coroutine.c

-              r78315272
+              r3f7e12cb
         if(pageSize == 0ul) pageSize = sysconf( _SC_PAGESIZE );
-        LIB_DEBUG_PRINT_SAFE("FRED");
         size_t cxtSize = libCeiling( sizeof(machine_context_t), 8 ); // minimum alignment
 …
                 this->limit = (char *)libCeiling( (unsigned long)this->storage, 16 ); // minimum alignment
         } // if
         assertf( this->size >= MinStackSize, "Stack size %d provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
+        assertf( this->size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", this->size, MinStackSize );
         this->base = (char *)this->limit + this->size;

src/libcfa/concurrency/invoke.h

-              r78315272
+              r3f7e12cb
 #define _INVOKE_H_
+      #define unlikely(x)    __builtin_expect(!!(x), 0)
+      #define thread_local _Thread_local
+      typedef void (*fptr_t)();
+      struct spinlock {
+            volatile int lock;
+            #ifdef __CFA_DEBUG__
+                  const char * prev_name;
+                  void* prev_thrd;
+            #endif
+      };
+      struct __thread_queue_t {
+            struct thread_desc * head;
+            struct thread_desc ** tail;
+      };
+      struct __condition_stack_t {
+            struct __condition_criterion_t * top;
+      };
+      #ifdef __CFORALL__
+      extern "Cforall" {
+            void ?{}( struct __thread_queue_t & );
+            void append( struct __thread_queue_t *, struct thread_desc * );
+            struct thread_desc * pop_head( struct __thread_queue_t * );
+            struct thread_desc * remove( struct __thread_queue_t *, struct thread_desc ** );
+            void ?{}( struct __condition_stack_t & );
+            void push( struct __condition_stack_t *, struct __condition_criterion_t * );
+            struct __condition_criterion_t * pop( struct __condition_stack_t * );
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
+      }
+      #endif
+      struct coStack_t {
+            unsigned int size;                        // size of stack
+            void *storage;                            // pointer to stack
+            void *limit;                              // stack grows towards stack limit
+            void *base;                               // base of stack
+            void *context;                            // address of cfa_context_t
+            void *top;                                // address of top of storage
+            bool userStack;                           // whether or not the user allocated the stack
+      };
+      enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+      struct coroutine_desc {
+            struct coStack_t stack;                   // stack information of the coroutine
+            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
+            int errno_;                               // copy of global UNIX variable errno
+            enum coroutine_state state;               // current execution status for coroutine
+            struct coroutine_desc * starter;          // first coroutine to resume this one
+            struct coroutine_desc * last;             // last coroutine to resume this one
+      };
+      struct monitor_desc {
+            struct spinlock lock;                     // spinlock to protect internal data
+            struct thread_desc * owner;               // current owner of the monitor
+            struct __thread_queue_t entry_queue;      // queue of threads that are blocked waiting for the monitor
+            struct __condition_stack_t signal_stack;  // stack of conditions to run next once we exit the monitor
+            unsigned int recursion;                   // monitor routines can be called recursively, we need to keep track of that
+            struct __acceptable_t * acceptables;      // list of acceptable functions, null if any
+            unsigned short acceptable_count;          // number of acceptable functions
+            short accepted_index;                     // the index of the accepted function, -1 if none
+       };
+      struct thread_desc {
+            // Core threading fields
+            struct coroutine_desc cor;                // coroutine body used to store context
+            struct monitor_desc mon;                  // monitor body used for mutual exclusion
+            // Link lists fields
+            struct thread_desc * next;                // instrusive link field for threads
+            // Current status related to monitors
+            struct monitor_desc ** current_monitors;  // currently held monitors
+            unsigned short current_monitor_count;     // number of currently held monitors
+            fptr_t current_monitor_func;              // last function that acquired monitors
+        #define unlikely(x)    __builtin_expect(!!(x), 0)
+        #define thread_local _Thread_local
+        typedef void (*fptr_t)();
+        typedef int_fast16_t __lock_size_t;
+        struct spinlock {
+                volatile int lock;
+                #ifdef __CFA_DEBUG__
+                        const char * prev_name;
+                        void* prev_thrd;
+                #endif
+        };
+        struct __thread_queue_t {
+                struct thread_desc * head;
+                struct thread_desc ** tail;
+        };
+        struct __condition_stack_t {
+                struct __condition_criterion_t * top;
+        };
+        #ifdef __CFORALL__
+        extern "Cforall" {
+                void ?{}( struct __thread_queue_t & );
+                void append( struct __thread_queue_t &, struct thread_desc * );
+                struct thread_desc * pop_head( struct __thread_queue_t & );
+                struct thread_desc * remove( struct __thread_queue_t &, struct thread_desc ** );
+                void ?{}( struct __condition_stack_t & );
+                void push( struct __condition_stack_t &, struct __condition_criterion_t * );
+                struct __condition_criterion_t * pop( struct __condition_stack_t & );
+                void  ?{}(spinlock & this);
+                void ^?{}(spinlock & this);
+        }
+        #endif
+        struct coStack_t {
+                // size of stack
+                size_t size;
+                // pointer to stack
+                void *storage;
+                // stack grows towards stack limit
+                void *limit;
+                // base of stack
+                void *base;
+                // address of cfa_context_t
+                void *context;
+                // address of top of storage
+                void *top;
+                // whether or not the user allocated the stack
+                bool userStack;
+        };
+        enum coroutine_state { Halted, Start, Inactive, Active, Primed };
+        struct coroutine_desc {
+                // stack information of the coroutine
+                struct coStack_t stack;
+                // textual name for coroutine/task, initialized by uC++ generated code
+                const char *name;
+                // copy of global UNIX variable errno
+                int errno_;
+                // current execution status for coroutine
+                enum coroutine_state state;
+                // first coroutine to resume this one
+                struct coroutine_desc * starter;
+                // last coroutine to resume this one
+                struct coroutine_desc * last;
+        };
+        struct __waitfor_mask_t {
+                // the index of the accepted function, -1 if none
+                short * accepted;
+                // list of acceptable functions, null if any
+                struct __acceptable_t * clauses;
+                // number of acceptable functions
+                __lock_size_t size;
+        };
+        struct monitor_desc {
+                // spinlock to protect internal data
+                struct spinlock lock;
+                // current owner of the monitor
+                struct thread_desc * owner;
+                // queue of threads that are blocked waiting for the monitor
+                struct __thread_queue_t entry_queue;
+                // stack of conditions to run next once we exit the monitor
+                struct __condition_stack_t signal_stack;
+                // monitor routines can be called recursively, we need to keep track of that
+                unsigned int recursion;
+                // mask used to know if some thread is waiting for something while holding the monitor
+                struct __waitfor_mask_t mask;
+                // node used to signal the dtor in a waitfor dtor
+                struct __condition_node_t * dtor_node;
+        };
+        struct __monitor_group_t {
+                // currently held monitors
+                struct monitor_desc ** list;
+                // number of currently held monitors
+                __lock_size_t size;
+                // last function that acquired monitors
+                fptr_t func;
+        };
+        struct thread_desc {
+                // Core threading fields
+                // coroutine body used to store context
+                struct coroutine_desc  self_cor;
+                // monitor body used for mutual exclusion
+                struct monitor_desc    self_mon;
+                // pointer to monitor with sufficient lifetime for current monitors
+                struct monitor_desc *  self_mon_p;
+                // monitors currently held by this thread
+                struct __monitor_group_t monitors;
+                // Link lists fields
+                // instrusive link field for threads
+                struct thread_desc * next;
      };
+     #ifdef __CFORALL__
+     extern "Cforall" {
+                static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
+                        return this.list[index];
+                }
+                static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
+                        if( (lhs.list != 0) != (rhs.list != 0) ) return false;
+                        if( lhs.size != rhs.size ) return false;
+                        if( lhs.func != rhs.func ) return false;
+                        // Check that all the monitors match
+                        for( int i = 0; i < lhs.size; i++ ) {
+                                // If not a match, check next function
+                                if( lhs[i] != rhs[i] ) return false;
+                        }
+                        return true;
+                }
+        }
+        #endif
 #endif //_INVOKE_H_
 …
 #define _INVOKE_PRIVATE_H_
       struct machine_context_t {
             void *SP;
             void *FP;
             void *PC;
       };
       // assembler routines that performs the context switch
       extern void CtxInvokeStub( void );
       void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
       #if   defined( __x86_64__ )
       #define CtxGet( ctx ) __asm__ ( \
                   "movq %%rsp,%0\n"   \
                   "movq %%rbp,%1\n"   \
             : "=rm" (ctx.SP), "=rm" (ctx.FP) )
       #elif defined( __i386__ )
       #define CtxGet( ctx ) __asm__ ( \
                   "movl %%esp,%0\n"   \
                   "movl %%ebp,%1\n"   \
             : "=rm" (ctx.SP), "=rm" (ctx.FP) )
       #endif
+        struct machine_context_t {
+                void *SP;
+                void *FP;
+                void *PC;
+        };
+        // assembler routines that performs the context switch
+        extern void CtxInvokeStub( void );
+        void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
+        #if   defined( __x86_64__ )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "movq %%rsp,%0\n"   \
+                        "movq %%rbp,%1\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #elif defined( __i386__ )
+        #define CtxGet( ctx ) __asm__ ( \
+                        "movl %%esp,%0\n"   \
+                        "movl %%ebp,%1\n"   \
+                : "=rm" (ctx.SP), "=rm" (ctx.FP) )
+        #endif
 #endif //_INVOKE_PRIVATE_H_

src/libcfa/concurrency/kernel

-              r78315272
+              r3f7e12cb
 //-----------------------------------------------------------------------------
 // Locks
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, spin if already acquired
+void lock_yield( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, yield repeatedly if already acquired
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );       // Lock the spinlock, return false if already acquired
+void unlock    ( spinlock * );                        // Unlock the spinlock
+// Lock the spinlock, spin if already acquired
+void lock      ( spinlock * DEBUG_CTX_PARAM2 );
+// Lock the spinlock, yield repeatedly if already acquired
+void lock_yield( spinlock * DEBUG_CTX_PARAM2 );
+// Lock the spinlock, return false if already acquired
+bool try_lock  ( spinlock * DEBUG_CTX_PARAM2 );
+// Unlock the spinlock
+void unlock    ( spinlock * );
 struct semaphore {
 …
 void  ?{}(semaphore & this, int count = 1);
 void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
+void   P (semaphore & this);
+void   V (semaphore & this);
 …
 // Cluster
 struct cluster {
+        spinlock ready_queue_lock;                      // Ready queue locks
+        __thread_queue_t ready_queue;                   // Ready queue for threads
+        unsigned long long int preemption;              // Preemption rate on this cluster
+        // Ready queue locks
+        spinlock ready_queue_lock;
+        // Ready queue for threads
+        __thread_queue_t ready_queue;
+        // Preemption rate on this cluster
+        unsigned long long int preemption;
 };
 void ?{}(cluster & this);
+void ?{} (cluster & this);
 void ^?{}(cluster & this);
 …
 struct processor {
         // Main state
+        struct processorCtx_t * runner;                 // Coroutine ctx who does keeps the state of the processor
+        cluster * cltr;                                 // Cluster from which to get threads
+        pthread_t kernel_thread;                        // Handle to pthreads
+        // Coroutine ctx who does keeps the state of the processor
+        struct processorCtx_t * runner;
+        // Cluster from which to get threads
+        cluster * cltr;
+        // Handle to pthreads
+        pthread_t kernel_thread;
         // Termination
+        volatile bool do_terminate;                     // Set to true to notify the processor should terminate
+        semaphore terminated;                           // Termination synchronisation
+        // Set to true to notify the processor should terminate
+        volatile bool do_terminate;
+        // Termination synchronisation
+        semaphore terminated;
         // RunThread data
+        struct FinishAction finish;                     // Action to do after a thread is ran
+        // Action to do after a thread is ran
+        struct FinishAction finish;
         // Preemption data
+        struct alarm_node_t * preemption_alarm;         // Node which is added in the discrete event simulaiton
+        bool pending_preemption;                        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        // Node which is added in the discrete event simulaiton
+        struct alarm_node_t * preemption_alarm;
+        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        bool pending_preemption;
 #ifdef __CFA_DEBUG__
+        char * last_enable;                             // Last function to enable preemption on this processor
+        // Last function to enable preemption on this processor
+        char * last_enable;
 #endif
 };
 void ?{}(processor & this);
 void ?{}(processor & this, cluster * cltr);
+void  ?{}(processor & this);
+void  ?{}(processor & this, cluster * cltr);
 void ^?{}(processor & this);

src/libcfa/concurrency/kernel.c

-              r78315272
+              r3f7e12cb
 void ?{}( thread_desc & this, current_stack_info_t * info) {
         (this.cor){ info };
+        (this.self_cor){ info };
+}
 …
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
                 this.do_terminate = true;
                 P( &this.terminated );
+                P( this.terminated );
                 pthread_join( this.kernel_thread, NULL );
+        }
 …
+        }
         V( &this->terminated );
+        V( this->terminated );
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
 …
         // if( !thrd ) return;
         verify( thrd );
         verify( thrd->cor.state != Halted );
+        verify( thrd->self_cor.state != Halted );
         verify( disable_preempt_count > 0 );
 …
         lock(   &this_processor->cltr->ready_queue_lock DEBUG_CTX2 );
         append( &this_processor->cltr->ready_queue, thrd );
+        append( this_processor->cltr->ready_queue, thrd );
         unlock( &this_processor->cltr->ready_queue_lock );
 …
         verify( disable_preempt_count > 0 );
         lock( &this->ready_queue_lock DEBUG_CTX2 );
         thread_desc * head = pop_head( &this->ready_queue );
+        thread_desc * head = pop_head( this->ready_queue );
         unlock( &this->ready_queue_lock );
         verify( disable_preempt_count > 0 );
 …
         assert(thrd);
         disable_interrupts();
         assert( thrd->cor.state != Halted );
+        assert( thrd->self_cor.state != Halted );
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
 …
+}
 void BlockInternal(spinlock ** locks, unsigned short count) {
+void BlockInternal(spinlock * locks [], unsigned short count) {
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi;
 …
+}
 void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
+void BlockInternal(spinlock * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
         disable_interrupts();
         this_processor->finish.action_code = Release_Multi_Schedule;
 …
         this_processor = mainProcessor;
         this_thread = mainThread;
         this_coroutine = &mainThread->cor;
+        this_coroutine = &mainThread->self_cor;
         // Enable preemption
 …
         thread_desc * thrd = kernel_data;
         int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->cor.name, thrd );
         __lib_debug_write( STDERR_FILENO, abort_text, len );
+        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
+        __lib_debug_write( abort_text, len );
         if ( thrd != this_coroutine ) {
                 len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine->name, this_coroutine );
                 __lib_debug_write( STDERR_FILENO, abort_text, len );
+                __lib_debug_write( abort_text, len );
+        }
         else {
                 __lib_debug_write( STDERR_FILENO, ".\n", 2 );
+                __lib_debug_write( ".\n", 2 );
+        }
+}
 …
 void ^?{}(semaphore & this) {}
 void P(semaphore * this) {
         lock( &this->lock DEBUG_CTX2 );
         this->count -= 1;
         if ( this->count < 0 ) {
+void P(semaphore & this) {
+        lock( &this.lock DEBUG_CTX2 );
+        this.count -= 1;
+        if ( this.count < 0 ) {
                 // queue current task
                 append( &this->waiting, (thread_desc *)this_thread );
+                append( this.waiting, (thread_desc *)this_thread );
                 // atomically release spin lock and block
                 BlockInternal( &this->lock );
+                BlockInternal( &this.lock );
+        }
         else {
             unlock( &this->lock );
+        }
+}
 void V(semaphore * this) {
+            unlock( &this.lock );
+        }
+}
+void V(semaphore & this) {
         thread_desc * thrd = NULL;
         lock( &this->lock DEBUG_CTX2 );
         this->count += 1;
         if ( this->count <= 0 ) {
+        lock( &this.lock DEBUG_CTX2 );
+        this.count += 1;
+        if ( this.count <= 0 ) {
                 // remove task at head of waiting list
                 thrd = pop_head( &this->waiting );
+        }
         unlock( &this->lock );
+                thrd = pop_head( this.waiting );
+        }
+        unlock( &this.lock );
         // make new owner
 …
+}
 void append( __thread_queue_t * this, thread_desc * t ) {
         verify(this->tail != NULL);
         *this->tail = t;
         this->tail = &t->next;
+}
 thread_desc * pop_head( __thread_queue_t * this ) {
         thread_desc * head = this->head;
+void append( __thread_queue_t & this, thread_desc * t ) {
+        verify(this.tail != NULL);
+        *this.tail = t;
+        this.tail = &t->next;
+}
+thread_desc * pop_head( __thread_queue_t & this ) {
+        thread_desc * head = this.head;
         if( head ) {
                 this->head = head->next;
+                this.head = head->next;
                 if( !head->next ) {
                         this->tail = &this->head;
+                        this.tail = &this.head;
+                }
                 head->next = NULL;
 …
+}
 thread_desc * remove( __thread_queue_t * this, thread_desc ** it ) {
+thread_desc * remove( __thread_queue_t & this, thread_desc ** it ) {
         thread_desc * thrd = *it;
         verify( thrd );
 …
         (*it) = thrd->next;
         if( this->tail == &thrd->next ) {
                 this->tail = it;
+        if( this.tail == &thrd->next ) {
+                this.tail = it;
+        }
         thrd->next = NULL;
         verify( (this->head == NULL) == (&this->head == this->tail) );
         verify( *this->tail == NULL );
+        verify( (this.head == NULL) == (&this.head == this.tail) );
+        verify( *this.tail == NULL );
         return thrd;
+}
 …
+}
 void push( __condition_stack_t * this, __condition_criterion_t * t ) {
+void push( __condition_stack_t & this, __condition_criterion_t * t ) {
         verify( !t->next );
         t->next = this->top;
         this->top = t;
+}
 __condition_criterion_t * pop( __condition_stack_t * this ) {
         __condition_criterion_t * top = this->top;
+        t->next = this.top;
+        this.top = t;
+}
+__condition_criterion_t * pop( __condition_stack_t & this ) {
+        __condition_criterion_t * top = this.top;
         if( top ) {
                 this->top = top->next;
+                this.top = top->next;
                 top->next = NULL;
+        }

src/libcfa/concurrency/kernel_private.h

-              r78315272
+              r3f7e12cb
 void BlockInternal(thread_desc * thrd);
 void BlockInternal(spinlock * lock, thread_desc * thrd);
 void BlockInternal(spinlock ** locks, unsigned short count);
 void BlockInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count);
+void BlockInternal(spinlock * locks [], unsigned short count);
+void BlockInternal(spinlock * locks [], unsigned short count, thread_desc * thrds [], unsigned short thrd_count);
 void LeaveThread(spinlock * lock, thread_desc * thrd);

src/libcfa/concurrency/monitor

-              r78315272
+              r3f7e12cb
 // Created On       : Thd Feb 23 12:27:26 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:59:01 2017
 // Update Count     : 3
+// Last Modified On : Sat Oct  7 18:06:45 2017
+// Update Count     : 10
 //
 …
 #include "stdlib"
+trait is_monitor(dtype T) {
+        monitor_desc * get_monitor( T & );
+        void ^?{}( T & mutex );
+};
 static inline void ?{}(monitor_desc & this) {
         (this.lock){};
-        this.owner = NULL;
         (this.entry_queue){};
         (this.signal_stack){};
+        this.recursion = 0;
+        this.acceptables = NULL;
+        this.acceptable_count = 0;
+        this.accepted_index = -1;
+        this.owner         = NULL;
+        this.recursion     = 0;
+        this.mask.accepted = NULL;
+        this.mask.clauses  = NULL;
+        this.mask.size     = 0;
+        this.dtor_node     = NULL;
+}
 struct monitor_guard_t {
         monitor_desc ** m;
         int count;
+        __lock_size_t   count;
         monitor_desc ** prev_mntrs;
         unsigned short  prev_count;
+        __lock_size_t   prev_count;
         fptr_t          prev_func;
 };
+static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
+        return ((intptr_t)lhs) < ((intptr_t)rhs);
+void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
+void ^?{}( monitor_guard_t & this );
+struct monitor_dtor_guard_t {
+        monitor_desc * m;
+        monitor_desc ** prev_mntrs;
+        __lock_size_t   prev_count;
+        fptr_t          prev_func;
+};
+void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
+void ^?{}( monitor_dtor_guard_t & this );
+static inline forall( dtype T | sized(T) | { void ^?{}( T & mutex ); } )
+void delete( T * th ) {
+        ^(*th){};
+        free( th );
+}
-void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() );
-void ^?{}( monitor_guard_t & this );
 //-----------------------------------------------------------------------------
 …
 struct __condition_criterion_t {
+        bool ready;                                             //Whether or not the criterion is met (True if met)
+        monitor_desc * target;                          //The monitor this criterion concerns
+        struct __condition_node_t * owner;              //The parent node to which this criterion belongs
+        __condition_criterion_t * next;         //Intrusive linked list Next field
+        // Whether or not the criterion is met (True if met)
+        bool ready;
+        // The monitor this criterion concerns
+        monitor_desc * target;
+        // The parent node to which this criterion belongs
+        struct __condition_node_t * owner;
+        // Intrusive linked list Next field
+        __condition_criterion_t * next;
 };
 struct __condition_node_t {
+        thread_desc * waiting_thread;                   //Thread that needs to be woken when all criteria are met
+        __condition_criterion_t * criteria;     //Array of criteria (Criterions are contiguous in memory)
+        unsigned short count;                           //Number of criterions in the criteria
+        __condition_node_t * next;                      //Intrusive linked list Next field
+        uintptr_t user_info;                            //Custom user info accessible before signalling
+        // Thread that needs to be woken when all criteria are met
+        thread_desc * waiting_thread;
+        // Array of criteria (Criterions are contiguous in memory)
+        __condition_criterion_t * criteria;
+        // Number of criterions in the criteria
+        __lock_size_t count;
+        // Intrusive linked list Next field
+        __condition_node_t * next;
+        // Custom user info accessible before signalling
+        uintptr_t user_info;
 };
 …
 };
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_criterion_t & this );
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
 void ?{}( __condition_blocked_queue_t & );
 void append( __condition_blocked_queue_t *, __condition_node_t * );
 __condition_node_t * pop_head( __condition_blocked_queue_t * );
+void append( __condition_blocked_queue_t &, __condition_node_t * );
+__condition_node_t * pop_head( __condition_blocked_queue_t & );
 struct condition {
+        __condition_blocked_queue_t blocked;    //Link list which contains the blocked threads as-well as the information needed to unblock them
+        monitor_desc ** monitors;                       //Array of monitor pointers (Monitors are NOT contiguous in memory)
+        unsigned short monitor_count;                   //Number of monitors in the array
+        // Link list which contains the blocked threads as-well as the information needed to unblock them
+        __condition_blocked_queue_t blocked;
+        // Array of monitor pointers (Monitors are NOT contiguous in memory)
+        monitor_desc ** monitors;
+        // Number of monitors in the array
+        __lock_size_t monitor_count;
 };
 …
+}
 void wait( condition * this, uintptr_t user_info = 0 );
 bool signal( condition * this );
 bool signal_block( condition * this );
 static inline bool is_empty( condition * this ) { return !this->blocked.head; }
 uintptr_t front( condition * this );
+              void wait        ( condition & this, uintptr_t user_info = 0 );
+              bool signal      ( condition & this );
+              bool signal_block( condition & this );
+static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
+         uintptr_t front       ( condition & this );
 //-----------------------------------------------------------------------------
 …
 struct __acceptable_t {
+        fptr_t func;
+        unsigned short count;
+        monitor_desc ** monitors;
+        __monitor_group_t;
         bool is_dtor;
 };
 int __accept_internal( unsigned short count, __acceptable_t * acceptables );
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
 // Local Variables: //

src/libcfa/concurrency/monitor.c

-              r78315272
+              r3f7e12cb
 #include <stdlib>
+#include <inttypes.h>
 #include "libhdr.h"
 #include "kernel_private.h"
+#include "bits/algorithms.h"
 //-----------------------------------------------------------------------------
 // Forward declarations
+static inline void set_owner( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * this, thread_desc * owner );
+static inline void set_owner ( monitor_desc * storage [], __lock_size_t count, thread_desc * owner );
+static inline void set_mask  ( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask );
+static inline void reset_mask( monitor_desc * this );
 static inline thread_desc * next_thread( monitor_desc * this );
+static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() );
+static inline void lock_all( spinlock ** locks, unsigned short count );
+static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count );
+static inline void unlock_all( spinlock ** locks, unsigned short count );
+static inline void unlock_all( monitor_desc ** locks, unsigned short count );
+static inline void save_recursion   ( monitor_desc ** ctx, unsigned int * /*out*/ recursions, unsigned short count );
+static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count );
+static inline void init     ( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
+static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria );
+static inline thread_desc * check_condition( __condition_criterion_t * );
+static inline void brand_condition( condition * );
+static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val );
+static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count );
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & monitors );
+static inline void lock_all  ( spinlock * locks [], __lock_size_t count );
+static inline void lock_all  ( monitor_desc * source [], spinlock * /*out*/ locks [], __lock_size_t count );
+static inline void unlock_all( spinlock * locks [], __lock_size_t count );
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count );
+static inline void save   ( monitor_desc * ctx [], __lock_size_t count, spinlock * locks [], unsigned int /*out*/ recursions [], __waitfor_mask_t /*out*/ masks [] );
+static inline void restore( monitor_desc * ctx [], __lock_size_t count, spinlock * locks [], unsigned int /*in */ recursions [], __waitfor_mask_t /*in */ masks [] );
+static inline void init     ( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] );
+static inline thread_desc *        check_condition   ( __condition_criterion_t * );
+static inline void                 brand_condition   ( condition & );
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t &, monitor_desc * monitors [], __lock_size_t count );
+forall(dtype T | sized( T ))
+static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val );
+static inline __lock_size_t count_max    ( const __waitfor_mask_t & mask );
+static inline __lock_size_t aggregate    ( monitor_desc * storage [], const __waitfor_mask_t & mask );
 //-----------------------------------------------------------------------------
 // Useful defines
+#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack       */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
+        init( count, monitors, &waiter, criteria );               /* Link everything together                                          */ \
+#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack       */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                   */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up          */ \
+        init_push( count, monitors, &waiter, criteria );          /* Link everything together and push it to the AS-Stack              */ \
+#define monitor_ctx( mons, cnt )              /* Define that create the necessary struct for internal/external scheduling operations */ \
+        monitor_desc ** monitors = mons;        /* Save the targeted monitors                                                          */ \
+        unsigned short count = cnt;             /* Save the count to a local variable                                                  */ \
+        unsigned int recursions[ count ];       /* Save the current recursion levels to restore them later                             */ \
+        spinlock *   locks     [ count ];       /* We need to pass-in an array of locks to BlockInternal                               */ \
+#define wait_ctx(thrd, user_info)                               /* Create the necessary information to use the signaller stack                         */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
+        init( count, monitors, waiter, criteria );                /* Link everything together                                                            */ \
+#define wait_ctx_primed(thrd, user_info)                        /* Create the necessary information to use the signaller stack                         */ \
+        __condition_node_t waiter = { thrd, count, user_info };   /* Create the node specific to this wait operation                                     */ \
+        __condition_criterion_t criteria[count];                  /* Create the creteria this wait operation needs to wake up                            */ \
+        init_push( count, monitors, waiter, criteria );           /* Link everything together and push it to the AS-Stack                                */ \
+#define monitor_ctx( mons, cnt )                                /* Define that create the necessary struct for internal/external scheduling operations */ \
+        monitor_desc ** monitors = mons;                          /* Save the targeted monitors                                                          */ \
+        __lock_size_t count = cnt;                                /* Save the count to a local variable                                                  */ \
+        unsigned int recursions[ count ];                         /* Save the current recursion levels to restore them later                             */ \
+        __waitfor_mask_t masks [ count ];                         /* Save the current waitfor masks to restore them later                                */ \
+        spinlock *   locks     [ count ];                         /* We need to pass-in an array of locks to BlockInternal                               */ \
+#define monitor_save    save   ( monitors, count, locks, recursions, masks )
+#define monitor_restore restore( monitors, count, locks, recursions, masks )
 //-----------------------------------------------------------------------------
 …
 extern "C" {
         // Enter single monitor
         static void __enter_monitor_desc( monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
+        static void __enter_monitor_desc( monitor_desc * this, const __monitor_group_t & group ) {
                 // Lock the monitor spinlock, lock_yield to reduce contention
                 lock_yield( &this->lock DEBUG_CTX2 );
 …
                 LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner);
-                this->accepted_index = -1;
                 if( !this->owner ) {
                         // No one has the monitor, just take it
 …
+                }
                 else if( this->owner == thrd) {
+                        // We already have the monitor, just not how many times we took it
+                        verify( this->recursion > 0 );
+                        // We already have the monitor, just note how many times we took it
                         this->recursion += 1;
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon already owned \n");
+                }
                 else if( (this->accepted_index = is_accepted( thrd, this, group, group_cnt, func)) >= 0 ) {
+                else if( is_accepted( this, group) ) {
                         // Some one was waiting for us, enter
                         set_owner( this, thrd );
+                        // Reset mask
+                        reset_mask( this );
                         LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts \n");
+                }
 …
                         // Some one else has the monitor, wait in line for it
                         append( &this->entry_queue, thrd );
+                        append( this->entry_queue, thrd );
                         BlockInternal( &this->lock );
 …
                 unlock( &this->lock );
                 return;
+        }
+        static void __enter_monitor_dtor( monitor_desc * this, fptr_t func ) {
+                // Lock the monitor spinlock, lock_yield to reduce contention
+                lock_yield( &this->lock DEBUG_CTX2 );
+                thread_desc * thrd = this_thread;
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Entering dtor for mon %p (%p)\n", thrd, this, this->owner);
+                if( !this->owner ) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel : Destroying free mon %p\n", this);
+                        // No one has the monitor, just take it
+                        set_owner( this, thrd );
+                        unlock( &this->lock );
+                        return;
+                }
+                else if( this->owner == thrd) {
+                        // We already have the monitor... but where about to destroy it so the nesting will fail
+                        // Abort!
+                        abortf("Attempt to destroy monitor %p by thread \"%.256s\" (%p) in nested mutex.");
+                }
+                __lock_size_t count = 1;
+                monitor_desc ** monitors = &this;
+                __monitor_group_t group = { &this, 1, func };
+                if( is_accepted( this, group) ) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  mon accepts dtor, block and signal it \n");
+                        // Wake the thread that is waiting for this
+                        __condition_criterion_t * urgent = pop( this->signal_stack );
+                        verify( urgent );
+                        // Reset mask
+                        reset_mask( this );
+                        // Create the node specific to this wait operation
+                        wait_ctx_primed( this_thread, 0 )
+                        // Some one else has the monitor, wait for him to finish and then run
+                        BlockInternal( &this->lock, urgent->owner->waiting_thread );
+                        // Some one was waiting for us, enter
+                        set_owner( this, thrd );
+                }
+                else {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  blocking \n");
+                        wait_ctx( this_thread, 0 )
+                        this->dtor_node = &waiter;
+                        // Some one else has the monitor, wait in line for it
+                        append( this->entry_queue, thrd );
+                        BlockInternal( &this->lock );
+                        // BlockInternal will unlock spinlock, no need to unlock ourselves
+                        return;
+                }
+                LIB_DEBUG_PRINT_SAFE("Kernel : Destroying %p\n", this);
+        }
 …
                 lock_yield( &this->lock DEBUG_CTX2 );
+                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i)", this_thread, this->owner, this->recursion );
+                LIB_DEBUG_PRINT_SAFE("Kernel : %10p Leaving mon %p (%p)\n", this_thread, this, this->owner);
+                verifyf( this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", this_thread, this->owner, this->recursion, this );
                 // Leaving a recursion level, decrement the counter
 …
                 // it means we don't need to do anything
                 if( this->recursion != 0) {
+                        LIB_DEBUG_PRINT_SAFE("Kernel :  recursion still %d\n", this->recursion);
                         unlock( &this->lock );
                         return;
 …
                 //We need to wake-up the thread
                 WakeThread( new_owner );
+        }
+        // Leave single monitor for the last time
+        void __leave_dtor_monitor_desc( monitor_desc * this ) {
+                LIB_DEBUG_DO(
+                        if( this_thread != this->owner ) {
+                                abortf("Destroyed monitor %p has inconsistent owner, expected %p got %p.\n", this, this_thread, this->owner);
+                        }
+                        if( this->recursion != 1 ) {
+                                abortf("Destroyed monitor %p has %d outstanding nested calls.\n", this, this->recursion - 1);
+                        }
+                )
+        }
 …
         // Should never return
         void __leave_thread_monitor( thread_desc * thrd ) {
                 monitor_desc * this = &thrd->mon;
+                monitor_desc * this = &thrd->self_mon;
                 // Lock the monitor now
 …
                 disable_interrupts();
                 thrd->cor.state = Halted;
                 verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i)", thrd, this->owner, this->recursion );
+                thrd->self_cor.state = Halted;
+                verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
                 // Leaving a recursion level, decrement the counter
 …
 // Enter multiple monitor
 // relies on the monitor array being sorted
 static inline void enter(monitor_desc ** monitors, int count, void (*func)() ) {
         for(int i = 0; i < count; i++) {
                 __enter_monitor_desc( monitors[i], monitors, count, func );
+static inline void enter( __monitor_group_t monitors ) {
+        for( __lock_size_t i = 0; i < monitors.size; i++) {
+                __enter_monitor_desc( monitors.list[i], monitors );
+        }
+}
 …
 // Leave multiple monitor
 // relies on the monitor array being sorted
 static inline void leave(monitor_desc ** monitors, int count) {
         for(int i = count - 1; i >= 0; i--) {
+static inline void leave(monitor_desc * monitors [], __lock_size_t count) {
+        for( __lock_size_t i = count - 1; i >= 0; i--) {
                 __leave_monitor_desc( monitors[i] );
+        }
 …
 // Ctor for monitor guard
 // Sorts monitors before entering
 void ?{}( monitor_guard_t & this, monitor_desc ** m, int count, void (*func)() ) {
+void ?{}( monitor_guard_t & this, monitor_desc * m [], __lock_size_t count, fptr_t func ) {
         // Store current array
         this.m = m;
 …
         // Sort monitors based on address -> TODO use a sort specialized for small numbers
         qsort(this.m, count);
+        __libcfa_small_sort(this.m, count);
         // Save previous thread context
+        this.prev_mntrs = this_thread->current_monitors;
+        this.prev_count = this_thread->current_monitor_count;
+        this.prev_func  = this_thread->current_monitor_func;
+        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
         // Update thread context (needed for conditions)
         this_thread->current_monitors      = m;
+        this_thread->current_monitor_count = count;
         this_thread->current_monitor_func  = func;
+        this_thread->monitors.[list, size, func] = [m, count, func];
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : enter %d\n", count);
         // Enter the monitors in order
+        enter( this.m, this.count, func );
+        __monitor_group_t group = {this.m, this.count, func};
+        enter( group );
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : entered\n");
+}
 …
 // Dtor for monitor guard
 void ^?{}( monitor_guard_t & this ) {
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : leaving %d\n", this.count);
         // Leave the monitors in order
         leave( this.m, this.count );
+        // LIB_DEBUG_PRINT_SAFE("MGUARD : left\n");
         // Restore thread context
+        this_thread->current_monitors      = this.prev_mntrs;
+        this_thread->current_monitor_count = this.prev_count;
+        this_thread->current_monitor_func  = this.prev_func;
+        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+}
+// Ctor for monitor guard
+// Sorts monitors before entering
+void ?{}( monitor_dtor_guard_t & this, monitor_desc * m [], fptr_t func ) {
+        // Store current array
+        this.m = *m;
+        // Save previous thread context
+        this.[prev_mntrs, prev_count, prev_func] = this_thread->monitors.[list, size, func];
+        // Update thread context (needed for conditions)
+        this_thread->monitors.[list, size, func] = [m, 1, func];
+        __enter_monitor_dtor( this.m, func );
+}
+// Dtor for monitor guard
+void ^?{}( monitor_dtor_guard_t & this ) {
+        // Leave the monitors in order
+        __leave_dtor_monitor_desc( this.m );
+        // Restore thread context
+        this_thread->monitors.[list, size, func] = this.[prev_mntrs, prev_count, prev_func];
+}
 //-----------------------------------------------------------------------------
 // Internal scheduling types
 void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info ) {
         this.waiting_thread = waiting_thread;
         this.count = count;
 …
+}
 void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t & owner ) {
         this.ready  = false;
         this.target = target;
         this.owner  = owner;
+        this.owner  = &owner;
         this.next   = NULL;
+}
 …
 //-----------------------------------------------------------------------------
 // Internal scheduling
 void wait( condition * this, uintptr_t user_info = 0 ) {
+void wait( condition & this, uintptr_t user_info = 0 ) {
         brand_condition( this );
         // Check that everything is as expected
         assertf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
         verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
         verifyf( this->monitor_count < 32u, "Excessive monitor count (%i)", this->monitor_count );
+        assertf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
+        verifyf( this.monitor_count < 32u, "Excessive monitor count (%"PRIiFAST16")", this.monitor_count );
         // Create storage for monitor context
         monitor_ctx( this->monitors, this->monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );
         // Create the node specific to this wait operation
 …
         // Append the current wait operation to the ones already queued on the condition
         // We don't need locks for that since conditions must always be waited on inside monitor mutual exclusion
         append( &this->blocked, &waiter );
         // Lock all monitors (aggregates the lock them as well)
+        append( this.blocked, &waiter );
+        // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
-        // DON'T unlock, ask the kernel to do it
-        // Save monitor state
-        save_recursion( monitors, recursions, count );
         // Find the next thread(s) to run
         unsigned short thread_count = 0;
+        __lock_size_t thread_count = 0;
         thread_desc * threads[ count ];
+        for(int i = 0; i < count; i++) {
+                threads[i] = 0;
+        }
+        __builtin_memset( threads, 0, sizeof( threads ) );
+        // Save monitor states
+        monitor_save;
         // Remove any duplicate threads
         for( int i = 0; i < count; i++) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( monitors[i] );
                 thread_count = insert_unique( threads, thread_count, new_owner );
+                insert_unique( threads, thread_count, new_owner );
+        }
 …
         BlockInternal( locks, count, threads, thread_count );
-        // WE WOKE UP
         // We are back, restore the owners and recursions
+        lock_all( locks, count );
+        restore_recursion( monitors, recursions, count );
+        unlock_all( locks, count );
+}
+bool signal( condition * this ) {
+        monitor_restore;
+}
+bool signal( condition & this ) {
         if( is_empty( this ) ) { return false; }
         //Check that everything is as expected
         verify( this->monitors );
         verify( this->monitor_count != 0 );
+        verify( this.monitors );
+        verify( this.monitor_count != 0 );
         //Some more checking in debug
         LIB_DEBUG_DO(
                 thread_desc * this_thrd = this_thread;
                 if ( this->monitor_count != this_thrd->current_monitor_count ) {
                         abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", this, this->monitor_count, this_thrd->current_monitor_count );
+                }
                 for(int i = 0; i < this->monitor_count; i++) {
                         if ( this->monitors[i] != this_thrd->current_monitors[i] ) {
                                 abortf( "Signal on condition %p made with different monitor, expected %p got %i", this, this->monitors[i], this_thrd->current_monitors[i] );
+                if ( this.monitor_count != this_thrd->monitors.size ) {
+                        abortf( "Signal on condition %p made with different number of monitor(s), expected %i got %i", &this, this.monitor_count, this_thrd->monitors.size );
+                }
+                for(int i = 0; i < this.monitor_count; i++) {
+                        if ( this.monitors[i] != this_thrd->monitors.list[i] ) {
+                                abortf( "Signal on condition %p made with different monitor, expected %p got %i", &this, this.monitors[i], this_thrd->monitors.list[i] );
+                        }
+                }
         );
         unsigned short count = this->monitor_count;
+        __lock_size_t count = this.monitor_count;
         // Lock all monitors
         lock_all( this->monitors, NULL, count );
+        lock_all( this.monitors, NULL, count );
         //Pop the head of the waiting queue
         __condition_node_t * node = pop_head( &this->blocked );
+        __condition_node_t * node = pop_head( this.blocked );
         //Add the thread to the proper AS stack
 …
                 __condition_criterion_t * crit = &node->criteria[i];
                 assert( !crit->ready );
                 push( &crit->target->signal_stack, crit );
+                push( crit->target->signal_stack, crit );
+        }
         //Release
         unlock_all( this->monitors, count );
+        unlock_all( this.monitors, count );
         return true;
+}
 bool signal_block( condition * this ) {
         if( !this->blocked.head ) { return false; }
+bool signal_block( condition & this ) {
+        if( !this.blocked.head ) { return false; }
         //Check that everything is as expected
         verifyf( this->monitors != NULL, "Waiting with no monitors (%p)", this->monitors );
         verifyf( this->monitor_count != 0, "Waiting with 0 monitors (%i)", this->monitor_count );
+        verifyf( this.monitors != NULL, "Waiting with no monitors (%p)", this.monitors );
+        verifyf( this.monitor_count != 0, "Waiting with 0 monitors (%"PRIiFAST16")", this.monitor_count );
         // Create storage for monitor context
         monitor_ctx( this->monitors, this->monitor_count );
+        monitor_ctx( this.monitors, this.monitor_count );
         // Lock all monitors (aggregates the locks them as well)
 …
         //save contexts
         save_recursion( monitors, recursions, count );
+        monitor_save;
         //Find the thread to run
         thread_desc * signallee = pop_head( &this->blocked )->waiting_thread;
         for(int i = 0; i < count; i++) {
+                set_owner( monitors[i], signallee );
+        }
+        thread_desc * signallee = pop_head( this.blocked )->waiting_thread;
+        set_owner( monitors, count, signallee );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : signal_block condition %p (s: %p)\n", &this, signallee );
         //Everything is ready to go to sleep
 …
         //We are back, restore the owners and recursions
+        lock_all( locks, count );
         restore_recursion( monitors, recursions, count );
         unlock_all( locks, count );
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :   signal_block returned\n" );
+        //We are back, restore the masks and recursions
+        monitor_restore;
         return true;
 …
 // Access the user_info of the thread waiting at the front of the queue
 uintptr_t front( condition * this ) {
+uintptr_t front( condition & this ) {
         verifyf( !is_empty(this),
                 "Attempt to access user data on an empty condition.\n"
                 "Possible cause is not checking if the condition is empty before reading stored data."
         );
         return this->blocked.head->user_info;
+        return this.blocked.head->user_info;
+}
 //-----------------------------------------------------------------------------
+// Internal scheduling
+int __accept_internal( unsigned short acc_count, __acceptable_t * acceptables ) {
+        thread_desc * thrd = this_thread;
+// External scheduling
+// cases to handle :
+//      - target already there :
+//              block and wake
+//      - dtor already there
+//              put thread on signaller stack
+//      - non-blocking
+//              return else
+//      - timeout
+//              return timeout
+//      - block
+//              setup mask
+//              block
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration ) {
+        // This statment doesn't have a contiguous list of monitors...
+        // Create one!
+        __lock_size_t max = count_max( mask );
+        monitor_desc * mon_storage[max];
+        __builtin_memset( mon_storage, 0, sizeof( mon_storage ) );
+        __lock_size_t actual_count = aggregate( mon_storage, mask );
+        LIB_DEBUG_PRINT_BUFFER_DECL( "Kernel : waitfor %d (s: %d, m: %d)\n", actual_count, mask.size, (__lock_size_t)max);
+        if(actual_count == 0) return;
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : waitfor internal proceeding\n");
         // Create storage for monitor context
         monitor_ctx( acceptables->monitors, acceptables->count );
         // Lock all monitors (aggregates the lock them as well)
+        monitor_ctx( mon_storage, actual_count );
+        // Lock all monitors (aggregates the locks as well)
         lock_all( monitors, locks, count );
+        {
+                // Check if the entry queue
+                thread_desc * next; int index;
+                [next, index] = search_entry_queue( mask, monitors, count );
+                if( next ) {
+                        *mask.accepted = index;
+                        if( mask.clauses[index].is_dtor ) {
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : dtor already there\n");
+                                verifyf( mask.clauses[index].size == 1        , "ERROR: Accepted dtor has more than 1 mutex parameter." );
+                                monitor_desc * mon2dtor = mask.clauses[index].list[0];
+                                verifyf( mon2dtor->dtor_node, "ERROR: Accepted monitor has no dtor_node." );
+                                __condition_criterion_t * dtor_crit = mon2dtor->dtor_node->criteria;
+                                push( mon2dtor->signal_stack, dtor_crit );
+                                unlock_all( locks, count );
+                        }
+                        else {
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, baton-passing\n");
+                                // Create the node specific to this wait operation
+                                wait_ctx_primed( this_thread, 0 );
+                                // Save monitor states
+                                monitor_save;
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel :  baton of %d monitors : ", count );
+                                #ifdef __CFA_DEBUG_PRINT__
+                                        for( int i = 0; i < count; i++) {
+                                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "%p %p ", monitors[i], monitors[i]->signal_stack.top );
+                                        }
+                                #endif
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "\n");
+                                // Set the owners to be the next thread
+                                set_owner( monitors, count, next );
+                                // Everything is ready to go to sleep
+                                BlockInternal( locks, count, &next, 1 );
+                                // We are back, restore the owners and recursions
+                                monitor_restore;
+                                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : thread present, returned\n");
+                        }
+                        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+                        return;
+                }
+        }
+        if( duration == 0 ) {
+                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : non-blocking, exiting\n");
+                unlock_all( locks, count );
+                LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+                return;
+        }
+        verifyf( duration < 0, "Timeout on waitfor statments not supported yet.");
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : blocking waitfor\n");
         // Create the node specific to this wait operation
+        wait_ctx_primed( thrd, 0 );
+        // Check if the entry queue
+        thread_desc * next = search_entry_queue( acceptables, acc_count, monitors, count );
+        LIB_DEBUG_PRINT_SAFE("Owner(s) :");
+        for(int i = 0; i < count; i++) {
+                LIB_DEBUG_PRINT_SAFE(" %p", monitors[i]->owner );
+        }
+        LIB_DEBUG_PRINT_SAFE("\n");
+        LIB_DEBUG_PRINT_SAFE("Passing mon to %p\n", next);
+        if( !next ) {
+                // Update acceptables on the current monitors
+                for(int i = 0; i < count; i++) {
+                        monitors[i]->acceptables = acceptables;
+                        monitors[i]->acceptable_count = acc_count;
+                }
+        }
+        else {
+                for(int i = 0; i < count; i++) {
+                        set_owner( monitors[i], next );
+                }
+        }
+        save_recursion( monitors, recursions, count );
+        // Everything is ready to go to sleep
+        BlockInternal( locks, count, &next, next ? 1 : 0 );
+        //WE WOKE UP
+        //We are back, restore the owners and recursions
+        lock_all( locks, count );
+        restore_recursion( monitors, recursions, count );
+        int acc_idx = monitors[0]->accepted_index;
+        unlock_all( locks, count );
+        return acc_idx;
+        wait_ctx_primed( this_thread, 0 );
+        monitor_save;
+        set_mask( monitors, count, mask );
+        for( __lock_size_t i = 0; i < count; i++) {
+                verify( monitors[i]->owner == this_thread );
+        }
+        //Everything is ready to go to sleep
+        BlockInternal( locks, count );
+        // WE WOKE UP
+        //We are back, restore the masks and recursions
+        monitor_restore;
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : exiting\n");
+        LIB_DEBUG_PRINT_BUFFER_LOCAL( "Kernel : accepted %d\n", *mask.accepted);
+}
 …
 static inline void set_owner( monitor_desc * this, thread_desc * owner ) {
+        // LIB_DEBUG_PRINT_SAFE("Kernal :   Setting owner of %p to %p ( was %p)\n", this, owner, this->owner );
         //Pass the monitor appropriately
         this->owner = owner;
 …
+}
+static inline void set_owner( monitor_desc * monitors [], __lock_size_t count, thread_desc * owner ) {
+        monitors[0]->owner     = owner;
+        monitors[0]->recursion = 1;
+        for( __lock_size_t i = 1; i < count; i++ ) {
+                monitors[i]->owner     = owner;
+                monitors[i]->recursion = 0;
+        }
+}
+static inline void set_mask( monitor_desc * storage [], __lock_size_t count, const __waitfor_mask_t & mask ) {
+        for( __lock_size_t i = 0; i < count; i++) {
+                storage[i]->mask = mask;
+        }
+}
+static inline void reset_mask( monitor_desc * this ) {
+        this->mask.accepted = NULL;
+        this->mask.clauses = NULL;
+        this->mask.size = 0;
+}
 static inline thread_desc * next_thread( monitor_desc * this ) {
         //Check the signaller stack
+        __condition_criterion_t * urgent = pop( &this->signal_stack );
+        LIB_DEBUG_PRINT_SAFE("Kernel :  mon %p AS-stack top %p\n", this, this->signal_stack.top);
+        __condition_criterion_t * urgent = pop( this->signal_stack );
         if( urgent ) {
                 //The signaller stack is not empty,
 …
         // No signaller thread
         // Get the next thread in the entry_queue
         thread_desc * new_owner = pop_head( &this->entry_queue );
+        thread_desc * new_owner = pop_head( this->entry_queue );
         set_owner( this, new_owner );
 …
+}
 static inline int is_accepted( thread_desc * owner, monitor_desc * this, monitor_desc ** group, int group_cnt, void (*func)() ) {
         __acceptable_t* accs = this->acceptables; // Optim
         int acc_cnt = this->acceptable_count;
+static inline bool is_accepted( monitor_desc * this, const __monitor_group_t & group ) {
+        __acceptable_t * it = this->mask.clauses; // Optim
+        __lock_size_t count = this->mask.size;
         // Check if there are any acceptable functions
         if( !accs ) return -1;
+        if( !it ) return false;
         // If this isn't the first monitor to test this, there is no reason to repeat the test.
         if( this != group[0] ) return group[0]->accepted_index;
+        if( this != group[0] ) return group[0]->mask.accepted >= 0;
         // For all acceptable functions check if this is the current function.
+        OUT_LOOP:
+        for( int i = 0; i < acc_cnt; i++ ) {
+                __acceptable_t * acc = &accs[i];
+                // if function matches, check the monitors
+                if( acc->func == func ) {
+                        // If the group count is different then it can't be a match
+                        if( acc->count != group_cnt ) return -1;
+                        // Check that all the monitors match
+                        for( int j = 0; j < group_cnt; j++ ) {
+                                // If not a match, check next function
+                                if( acc->monitors[j] != group[j] ) continue OUT_LOOP;
+                        }
+                        // It's a complete match, accept the call
+                        return i;
+        for( __lock_size_t i = 0; i < count; i++, it++ ) {
+                if( *it == group ) {
+                        *this->mask.accepted = i;
+                        return true;
+                }
+        }
         // No function matched
         return -1;
+}
 static inline void init( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
         for(int i = 0; i < count; i++) {
+        return false;
+}
+static inline void init( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
+        }
         waiter->criteria = criteria;
+}
 static inline void init_push( int count, monitor_desc ** monitors, __condition_node_t * waiter, __condition_criterion_t * criteria ) {
         for(int i = 0; i < count; i++) {
+        waiter.criteria = criteria;
+}
+static inline void init_push( __lock_size_t count, monitor_desc * monitors [], __condition_node_t & waiter, __condition_criterion_t criteria [] ) {
+        for( __lock_size_t i = 0; i < count; i++) {
                 (criteria[i]){ monitors[i], waiter };
+                push( &criteria[i].target->signal_stack, &criteria[i] );
+        }
+        waiter->criteria = criteria;
+}
+static inline void lock_all( spinlock ** locks, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
+                LIB_DEBUG_PRINT_SAFE( "Kernel :  target %p = %p\n", criteria[i].target, &criteria[i] );
+                push( criteria[i].target->signal_stack, &criteria[i] );
+        }
+        waiter.criteria = criteria;
+}
+static inline void lock_all( spinlock * locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 lock_yield( locks[i] DEBUG_CTX2 );
+        }
+}
 static inline void lock_all( monitor_desc ** source, spinlock ** /*out*/ locks, unsigned short count ) {
         for( int i = 0; i < count; i++ ) {
+static inline void lock_all( monitor_desc * source [], spinlock * /*out*/ locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 spinlock * l = &source[i]->lock;
                 lock_yield( l DEBUG_CTX2 );
 …
+}
 static inline void unlock_all( spinlock ** locks, unsigned short count ) {
         for( int i = 0; i < count; i++ ) {
+static inline void unlock_all( spinlock * locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( locks[i] );
+        }
+}
 static inline void unlock_all( monitor_desc ** locks, unsigned short count ) {
         for( int i = 0; i < count; i++ ) {
+static inline void unlock_all( monitor_desc * locks [], __lock_size_t count ) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 unlock( &locks[i]->lock );
+        }
+}
+static inline void save_recursion   ( monitor_desc ** ctx, unsigned int * /*out*/ recursions, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
+static inline void save(
+        monitor_desc * ctx [],
+        __lock_size_t count,
+        __attribute((unused)) spinlock * locks [],
+        unsigned int /*out*/ recursions [],
+        __waitfor_mask_t /*out*/ masks []
+) {
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 recursions[i] = ctx[i]->recursion;
+        }
+}
+static inline void restore_recursion( monitor_desc ** ctx, unsigned int * /*in */ recursions, unsigned short count ) {
+        for( int i = 0; i < count; i++ ) {
+                masks[i]      = ctx[i]->mask;
+        }
+}
+static inline void restore(
+        monitor_desc * ctx [],
+        __lock_size_t count,
+        spinlock * locks [],
+        unsigned int /*out*/ recursions [],
+        __waitfor_mask_t /*out*/ masks []
+) {
+        lock_all( locks, count );
+        for( __lock_size_t i = 0; i < count; i++ ) {
                 ctx[i]->recursion = recursions[i];
+        }
+                ctx[i]->mask      = masks[i];
+        }
+        unlock_all( locks, count );
+}
 …
+        }
         // LIB_DEBUG_PRINT_SAFE( "Runing %i\n", ready2run );
+        LIB_DEBUG_PRINT_SAFE( "Kernel :  Runing %i (%p)\n", ready2run, ready2run ? node->waiting_thread : NULL );
         return ready2run ? node->waiting_thread : NULL;
+}
 static inline void brand_condition( condition * this ) {
+static inline void brand_condition( condition & this ) {
         thread_desc * thrd = this_thread;
         if( !this->monitors ) {
+        if( !this.monitors ) {
                 // LIB_DEBUG_PRINT_SAFE("Branding\n");
+                assertf( thrd->current_monitors != NULL, "No current monitor to brand condition %p", thrd->current_monitors );
+                this->monitor_count = thrd->current_monitor_count;
+                this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
+                for( int i = 0; i < this->monitor_count; i++ ) {
+                        this->monitors[i] = thrd->current_monitors[i];
+                }
+        }
+}
+static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val ) {
+        if( !val ) return end;
+        for(int i = 0; i <= end; i++) {
+                if( thrds[i] == val ) return end;
+        }
+        thrds[end] = val;
+        return end + 1;
+}
+static inline bool match( __acceptable_t * acc, thread_desc * thrd ) {
+        verify( thrd );
+        verify( acc );
+        if( acc->func != thrd->current_monitor_func ) return false;
+        return true;
+}
+static inline thread_desc * search_entry_queue( __acceptable_t * acceptables, int acc_count, monitor_desc ** monitors, int count ) {
+        __thread_queue_t * entry_queue = &monitors[0]->entry_queue;
+                assertf( thrd->monitors.list != NULL, "No current monitor to brand condition %p", thrd->monitors.list );
+                this.monitor_count = thrd->monitors.size;
+                this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+                for( int i = 0; i < this.monitor_count; i++ ) {
+                        this.monitors[i] = thrd->monitors.list[i];
+                }
+        }
+}
+static inline [thread_desc *, int] search_entry_queue( const __waitfor_mask_t & mask, monitor_desc * monitors [], __lock_size_t count ) {
+        __thread_queue_t & entry_queue = monitors[0]->entry_queue;
         // For each thread in the entry-queue
         for(    thread_desc ** thrd_it = &entry_queue->head;
+        for(    thread_desc ** thrd_it = &entry_queue.head;
                 *thrd_it;
                 thrd_it = &(*thrd_it)->next)
+        {
+                thrd_it = &(*thrd_it)->next
+        ) {
                 // For each acceptable check if it matches
+                __acceptable_t * acc_end = acceptables + acc_count;
+                for( __acceptable_t * acc_it = acceptables; acc_it != acc_end; acc_it++ ) {
+                int i = 0;
+                __acceptable_t * end = mask.clauses + mask.size;
+                for( __acceptable_t * it = mask.clauses; it != end; it++, i++ ) {
                         // Check if we have a match
                         if( match( acc_it, *thrd_it ) ) {
+                        if( *it == (*thrd_it)->monitors ) {
                                 // If we have a match return it
                                 // after removeing it from the entry queue
                                 return remove( entry_queue, thrd_it );
+                                return [remove( entry_queue, thrd_it ), i];
+                        }
+                }
+        }
+        return NULL;
+}
+        return [0, -1];
+}
+forall(dtype T | sized( T ))
+static inline __lock_size_t insert_unique( T * array [], __lock_size_t & size, T * val ) {
+        if( !val ) return size;
+        for( __lock_size_t i = 0; i <= size; i++) {
+                if( array[i] == val ) return size;
+        }
+        array[size] = val;
+        size = size + 1;
+        return size;
+}
+static inline __lock_size_t count_max( const __waitfor_mask_t & mask ) {
+        __lock_size_t max = 0;
+        for( __lock_size_t i = 0; i < mask.size; i++ ) {
+                max += mask.clauses[i].size;
+        }
+        return max;
+}
+static inline __lock_size_t aggregate( monitor_desc * storage [], const __waitfor_mask_t & mask ) {
+        __lock_size_t size = 0;
+        for( __lock_size_t i = 0; i < mask.size; i++ ) {
+                __libcfa_small_sort( mask.clauses[i].list, mask.clauses[i].size );
+                for( __lock_size_t j = 0; j < mask.clauses[i].size; j++) {
+                        insert_unique( storage, size, mask.clauses[i].list[j] );
+                }
+        }
+        // TODO insertion sort instead of this
+        __libcfa_small_sort( storage, size );
+        return size;
+}
 void ?{}( __condition_blocked_queue_t & this ) {
         this.head = NULL;
 …
+}
 void append( __condition_blocked_queue_t * this, __condition_node_t * c ) {
         verify(this->tail != NULL);
         *this->tail = c;
         this->tail = &c->next;
+}
 __condition_node_t * pop_head( __condition_blocked_queue_t * this ) {
         __condition_node_t * head = this->head;
+void append( __condition_blocked_queue_t & this, __condition_node_t * c ) {
+        verify(this.tail != NULL);
+        *this.tail = c;
+        this.tail = &c->next;
+}
+__condition_node_t * pop_head( __condition_blocked_queue_t & this ) {
+        __condition_node_t * head = this.head;
         if( head ) {
                 this->head = head->next;
+                this.head = head->next;
                 if( !head->next ) {
                         this->tail = &this->head;
+                        this.tail = &this.head;
+                }
                 head->next = NULL;

src/libcfa/concurrency/preemption.c

-              r78315272
+              r3f7e12cb
                 siginfo_t info;
                 int sig = sigwaitinfo( &mask, &info );
+                if( sig < 0 ) {
+                        //Error!
+                        int err = errno;
+                        switch( err ) {
+                                case EAGAIN :
+                                case EINTR :
+                                        continue;
+                        case EINVAL :
+                                        abortf("Timeout was invalid.");
+                                default:
+                                        abortf("Unhandled error %d", err);
+                        }
+                }
                 // If another signal arrived something went wrong
 …
         if ( sigaction( sig, &act, NULL ) == -1 ) {
                 LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO,
+                LIB_DEBUG_PRINT_BUFFER_DECL(
                         " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
                         sig, handler, flags, errno, strerror( errno )
 …
         if ( sigaction( sig, &act, NULL ) == -1 ) {
                 LIB_DEBUG_PRINT_BUFFER_DECL( STDERR_FILENO,
+                LIB_DEBUG_PRINT_BUFFER_DECL(
                         " __kernel_sigdefault( sig:%d ), problem reseting signal handler, error(%d) %s.\n",
                         sig, errno, strerror( errno )

src/libcfa/concurrency/thread

r78315272	r3f7e12cb
36	36	forall( dtype T \| is_thread(T) )
37	37	static inline coroutine_desc* get_coroutine(T & this) {
38		return &get_thread(this)->cor;
	38	return &get_thread(this)->self_cor;
39	39	}
40	40
41	41	forall( dtype T \| is_thread(T) )
42	42	static inline monitor_desc* get_monitor(T & this) {
43		return &get_thread(this)->mon;
	43	return &get_thread(this)->self_mon;
44	44	}
45	45
46	46	static inline coroutine_desc* get_coroutine(thread_desc * this) {
47		return &this->cor;
	47	return &this->self_cor;
48	48	}
49	49
50	50	static inline monitor_desc* get_monitor(thread_desc * this) {
51		return &this->mon;
	51	return &this->self_mon;
52	52	}
53	53

src/libcfa/concurrency/thread.c

-              r78315272
+              r3f7e12cb
 void ?{}(thread_desc& this) {
+        (this.cor){};
+        this.cor.name = "Anonymous Coroutine";
+        this.mon.owner = &this;
+        this.mon.recursion = 1;
+        (this.self_cor){};
+        this.self_cor.name = "Anonymous Coroutine";
+        this.self_mon.owner = &this;
+        this.self_mon.recursion = 1;
+        this.self_mon_p = &this.self_mon;
         this.next = NULL;
+        this.current_monitors      = &this.mon;
+        this.current_monitor_count = 1;
+        (this.monitors){ &this.self_mon_p, 1, (fptr_t)0 };
+}
 void ^?{}(thread_desc& this) {
         ^(this.cor){};
+        ^(this.self_cor){};
+}

src/libcfa/interpose.c

-              r78315272
+              r3f7e12cb
                         va_end( args );
                         __lib_debug_write( STDERR_FILENO, abort_text, len );
                         __lib_debug_write( STDERR_FILENO, "\n", 1 );
+                        __lib_debug_write( abort_text, len );
+                        __lib_debug_write( "\n", 1 );
+                }
                 len = snprintf( abort_text, abort_text_size, "Cforall Runtime error (UNIX pid:%ld)\n", (long int)getpid() ); // use UNIX pid (versus getPid)
                 __lib_debug_write( STDERR_FILENO, abort_text, len );
+                __lib_debug_write( abort_text, len );

src/libcfa/iostream

-              r78315272
+              r3f7e12cb
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 13 12:53:46 2017
 // Update Count     : 138
+// Last Modified On : Tue Oct 10 14:51:10 2017
+// Update Count     : 140
 //
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char16_t * );
+#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char32_t * );
+#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const wchar_t * );
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );

src/libcfa/iostream.c

-              r78315272
+              r3f7e12cb
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Sep 17 23:24:25 2017
 // Update Count     : 422
+// Last Modified On : Tue Oct 10 14:51:09 2017
+// Update Count     : 424
 //
 …
 } // ?|?
+#if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 forall( dtype ostype | ostream( ostype ) )
 ostype * ?|?( ostype * os, const char32_t * str ) {
 …
         return os;
 } // ?|?
+#endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
 forall( dtype ostype | ostream( ostype ) )

src/libcfa/libhdr/libdebug.c

-              r78315272
+              r3f7e12cb
 // Author           : Thierry Delisle
 // Created On       : Thu Mar 30 12:30:01 2017
 // Last Modified By :
 // Last Modified On :
+// Last Modified By :
+// Last Modified On :
 // Update Count     : 0
 //
 …
 extern "C" {
         void __lib_debug_write( int fd, const char *in_buffer, int len ) {
+        void __lib_debug_write( const char *in_buffer, int len ) {
                 // ensure all data is written
                 for ( int count = 0, retcode; count < len; count += retcode ) {
+                for ( int count = 0, retcode; count < len; count += retcode ) {
                         in_buffer += count;
                         for ( ;; ) {
                                 retcode = write( fd, in_buffer, len - count );
+                                retcode = write( STDERR_FILENO, in_buffer, len - count );
                                 // not a timer interrupt ?
                                 if ( retcode != -1 || errno != EINTR ) break;
+                                if ( retcode != -1 || errno != EINTR ) break;
+                        }
 …
                 va_start( args, fmt );
                 __lib_debug_acquire();
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __lib_debug_write( STDERR_FILENO, buffer, len );
+                __lib_debug_write( buffer, len );
                 __lib_debug_release();
 …
                 va_start( args, fmt );
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __lib_debug_write( STDERR_FILENO, buffer, len );
+                __lib_debug_write( buffer, len );
                 va_end( args );
 …
         void __lib_debug_print_vararg( const char fmt[], va_list args ) {
                 int len = vsnprintf( buffer, buffer_size, fmt, args );
                 __lib_debug_write( STDERR_FILENO, buffer, len );
+                __lib_debug_write( buffer, len );
+        }
 …
                 va_start( args, fmt );
                 int len = vsnprintf( in_buffer, in_buffer_size, fmt, args );
                 __lib_debug_write( STDERR_FILENO, in_buffer, len );
+                __lib_debug_write( in_buffer, len );
                 va_end( args );

src/libcfa/libhdr/libdebug.h

-              r78315272
+              r3f7e12cb
 extern "C" {
 #endif
+      #include <stdarg.h>
+        #include <stdarg.h>
+        #include <stdio.h>
       extern void __lib_debug_write( int fd, const char *buffer, int len );
+      extern void __lib_debug_write( const char *buffer, int len );
       extern void __lib_debug_acquire();
       extern void __lib_debug_release();
 …
 #ifdef __CFA_DEBUG_PRINT__
         #define LIB_DEBUG_WRITE( fd, buffer, len )     __lib_debug_write( fd, buffer, len )
+        #define LIB_DEBUG_WRITE( buffer, len )         __lib_debug_write( buffer, len )
         #define LIB_DEBUG_ACQUIRE()                    __lib_debug_acquire()
         #define LIB_DEBUG_RELEASE()                    __lib_debug_release()
 …
         #define LIB_DEBUG_PRINT_NOLOCK(...)            __lib_debug_print_nolock (__VA_ARGS__)
         #define LIB_DEBUG_PRINT_BUFFER(...)            __lib_debug_print_buffer (__VA_ARGS__)
         #define LIB_DEBUG_PRINT_BUFFER_DECL(fd, ...)   char text[256]; int len = snprintf( text, 256, __VA_ARGS__ ); __lib_debug_write( fd, text, len );
         #define LIB_DEBUG_PRINT_BUFFER_LOCAL(fd, ...)  len = snprintf( text, 256, __VA_ARGS__ ); __lib_debug_write( fd, text, len );
+        #define LIB_DEBUG_PRINT_BUFFER_DECL(...)       char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
+        #define LIB_DEBUG_PRINT_BUFFER_LOCAL(...)      __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __lib_debug_write( __dbg_text, __dbg_len );
 #else
         #define LIB_DEBUG_WRITE(...)               ((void)0)

src/libcfa/stdlib

-              r78315272
+              r3f7e12cb
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 23 20:29:47 2017
 // Update Count     : 224
+// Last Modified On : Tue Oct 31 13:47:24 2017
+// Update Count     : 245
 //
 …
 // allocation, non-array types
 static inline forall( dtype T | sized(T) ) T * malloc( void ) {
         //printf( "X1\n" );
+        // printf( "* malloc\n" );
         return (T *)(void *)malloc( (size_t)sizeof(T) );        // C malloc
 } // malloc
+// static inline forall( dtype T | sized(T) ) T & malloc( void ) {
+//      int & p = *(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+//      printf( "& malloc %p\n", &p );
+//      return p;
+// //   return (T &)*(T *)(void *)malloc( (size_t)sizeof(T) ); // C malloc
+// } // malloc
 extern "C" { void * calloc( size_t dim, size_t size ); } // default C routine
 …
 //---------------------------------------
+void rand48seed( long int s );
+char rand48( void );
+int rand48( void );
+unsigned int rand48( void );
+long int rand48( void );
+unsigned long int rand48( void );
+float rand48( void );
+double rand48( void );
+float _Complex rand48( void );
+double _Complex rand48( void );
+long double _Complex rand48( void );
+void random_seed( long int s );
+char random( void );
+char random( char l, char u );
+int random( void );
+unsigned int random( void );
+unsigned int random( unsigned int u );
+unsigned int random( unsigned int l, unsigned int u );
+//long int random( void );
+unsigned long int random( void );
+unsigned long int random( unsigned long int u );
+unsigned long int random( unsigned long int l, unsigned long int u );
+float random( void );
+double random( void );
+float _Complex random( void );
+double _Complex random( void );
+long double _Complex random( void );
 //---------------------------------------

src/libcfa/stdlib.c

-              r78315272
+              r3f7e12cb
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 23 20:30:44 2017
 // Update Count     : 292
+// Last Modified On : Mon Oct 30 22:43:02 2017
+// Update Count     : 297
 //
 …
 //---------------------------------------
+void rand48seed( long int s ) { srand48( s ); }
+char rand48( void ) { return mrand48(); }
+int rand48( void ) { return mrand48(); }
+unsigned int rand48( void ) { return lrand48(); }
+long int rand48( void ) { return mrand48(); }
+unsigned long int rand48( void ) { return lrand48(); }
+float rand48( void ) { return (float)drand48(); }               // otherwise float uses lrand48
+double rand48( void ) { return drand48(); }
+float _Complex rand48( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex rand48( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex rand48( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
+void random_seed( long int s ) { srand48( s ); }
+char random( void ) { return mrand48(); }
+char random( char l, char u ) { return lrand48() % (u - l) + l; }
+int random( void ) { return mrand48(); }
+unsigned int random( void ) { return lrand48(); }
+unsigned int random( unsigned int u ) { return lrand48() % u; }
+unsigned int random( unsigned int l, unsigned int u ) { return lrand48() % (u - l) + l; }
+//long int random( void ) { return mrand48(); }
+unsigned long int random( void ) { return lrand48(); }
+unsigned long int random( unsigned long int u ) { return lrand48() % u; }
+unsigned long int random( unsigned long int l, unsigned long int u ) { return lrand48() % (u - l) + l; }
+float random( void ) { return (float)drand48(); }               // otherwise float uses lrand48
+double random( void ) { return drand48(); }
+float _Complex random( void ) { return (float)drand48() + (float _Complex)(drand48() * _Complex_I); }
+double _Complex random( void ) { return drand48() + (double _Complex)(drand48() * _Complex_I); }
+long double _Complex random( void) { return (long double)drand48() + (long double _Complex)(drand48() * _Complex_I); }
 //---------------------------------------

src/main.cc

-              r78315272
+              r3f7e12cb
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Jul 26 14:38:00 2017
 // Update Count     : 443
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Oct 31 12:22:40 2017
+// Update Count     : 445
 //
 …
 #include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
-#include "GenPoly/CopyParams.h"             // for copyParams
 #include "GenPoly/InstantiateGeneric.h"     // for instantiateGeneric
 #include "GenPoly/Lvalue.h"                 // for convertLvalue
 …
         codegenp = false,
         prettycodegenp = false,
         nolinemarks = false;
+        linemarks = false;
 static void parse_cmdline( int argc, char *argv[], const char *& filename );
 …
                 } // if
-                // OPTPRINT( "Concurrency" )
-                // Concurrency::applyKeywords( translationUnit );
                 // add the assignment statement after the initialization of a type parameter
                 OPTPRINT( "validate" )
 …
                 OPTPRINT("instantiateGenerics")
                 GenPoly::instantiateGeneric( translationUnit );
-                OPTPRINT( "copyParams" );
-                GenPoly::copyParams( translationUnit );
                 OPTPRINT( "convertLvalue" )
                 GenPoly::convertLvalue( translationUnit );
 …
                 CodeTools::fillLocations( translationUnit );
                 CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true, ! nolinemarks );
+                CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true, linemarks );
                 CodeGen::FixMain::fix( *output, treep ? "../prelude/bootloader.c" : CFA_LIBDIR "/bootloader.c" );
 …
 void parse_cmdline( int argc, char * argv[], const char *& filename ) {
         enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
+        enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
         static struct option long_opts[] = {
 …
                 { "grammar", no_argument, 0, Grammar },
                 { "libcfa", no_argument, 0, LibCFA },
+                { "line-marks", no_argument, 0, Linemarks },
+                { "no-line-marks", no_argument, 0, Nolinemarks },
                 { "no-preamble", no_argument, 0, Nopreamble },
                 { "parse", no_argument, 0, Parse },
 …
         int c;
         while ( (c = getopt_long( argc, argv, "abBcCdefglLmnpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcCdefglLmnNpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
 …
                         libcfap = true;
                         break;
+                  case 'L':                                                                             // surpress lines marks
+                        nolinemarks = true;
+                  case Linemarks:
+                  case 'L':                                                                             // print lines marks
+                        linemarks = true;
                         break;
                   case Nopreamble:
                   case 'n':                                                                             // do not read preamble
                         nopreludep = true;
+                        break;
+                  case Nolinemarks:
+                  case 'N':                                                                             // suppress line marks
+                        linemarks = false;
                         break;
                   case Prototypes:
 …
                                 assertf( false, "Unknown option: %s\n", argv[optind - 1] );
                         } // if
+                        #if __GNUC__ < 7
+                        #else
+                                __attribute__((fallthrough));
+                        #endif
                   default:
                         abort();

src/prelude/Makefile.am

r78315272	r3f7e12cb
57	57
58	58	bootloader.c : bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
59		${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
	59	${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpm bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
60	60
61	61	maintainer-clean-local :

src/prelude/Makefile.in

r78315272	r3f7e12cb
526	526
527	527	bootloader.c : bootloader.cf prelude.cf extras.cf gcc-builtins.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
528		${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
	528	${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpm bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
529	529
530	530	maintainer-clean-local :

src/prelude/extras.c

r78315272	r3f7e12cb
1	1	#include <stddef.h> // size_t, ptrdiff_t
	2	#include <stdint.h> // intX_t, uintX_t, where X is 8, 16, 32, 64
2	3	#include <uchar.h> // char16_t, char32_t
3	4	#include <wchar.h> // wchar_t

src/prelude/extras.regx

-              r78315272
+              r3f7e12cb
 typedef.* size_t;
 typedef.* ptrdiff_t;
+typedef.* int8_t;
+typedef.* int16_t;
+typedef.* int32_t;
+typedef.* int64_t;
+typedef.* uint8_t;
+typedef.* uint16_t;
+typedef.* uint32_t;
+typedef.* uint64_t;
 typedef.* char16_t;
 typedef.* char32_t;

src/prelude/prelude.cf

-              r78315272
+              r3f7e12cb
 // Created On       : Sat Nov 29 07:23:41 2014
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 30 07:56:07 2017
 // Update Count     : 93
+// Last Modified On : Sat Oct 28 16:33:09 2017
+// Update Count     : 102
 //
 …
 _Bool                   ?++( _Bool & ),                         ?++( volatile _Bool & );
 _Bool                   ?--( _Bool & ),                         ?--( volatile _Bool & );
+unsigned char           ?++( unsigned char & ),                 ?++( volatile unsigned char & );
+signed short            ?++( signed short & ),                  ?++( volatile signed short & );
+signed short            ?--( signed short & ),                  ?--( volatile signed short & );
+unsigned short          ?++( unsigned short & ),                ?++( volatile unsigned short & );
+unsigned short          ?--( unsigned short & ),                ?--( volatile unsigned short & );
 signed int              ?++( signed int & ),                    ?++( volatile signed int & );
 signed int              ?--( signed int & ),                    ?--( volatile signed int & );
 …
 _Bool                   ++?( _Bool & ),                         --?( _Bool & );
+signed short    ++?( signed short & ),                  --?( signed short & );
 signed int              ++?( signed int & ),                    --?( signed int & );
+unsigned int            ++?( unsigned int & ),                  --?( unsigned int & );
+unsigned short          ++?( unsigned int & ),                  --?( unsigned int & );
+unsigned int            ++?( unsigned short & ),                --?( unsigned short & );
 signed long int         ++?( signed long int & ),               --?( signed long int & );
 unsigned long int       ++?( unsigned long int & ),             --?( unsigned long int & );
 …
 long double _Complex    ?+?( long double _Complex, long double _Complex ),      ?-?( long double _Complex, long double _Complex );
 forall( dtype T | sized(T) ) T *                        ?+?(                T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?+?(          ptrdiff_t,                T * );
+forall( dtype T | sized(T) ) T *                ?+?(                T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) T *                ?+?(          ptrdiff_t,                T * );
 forall( dtype T | sized(T) ) const T *          ?+?( const          T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?+?(          ptrdiff_t, const          T * );
 forall( dtype T | sized(T) ) volatile T *               ?+?(       volatile T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?+?(          ptrdiff_t,       volatile T * );
+forall( dtype T | sized(T) ) volatile T *       ?+?(       volatile T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *       ?+?(          ptrdiff_t,       volatile T * );
 forall( dtype T | sized(T) ) const volatile T * ?+?( const volatile T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?+?(          ptrdiff_t, const volatile T * );
 forall( dtype T | sized(T) ) T *                        ?-?(                T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) T *                ?-?(                T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?-?( const          T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?-?(       volatile T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *       ?-?(       volatile T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?-?( const volatile T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) ptrdiff_t          ?-?( const volatile T *, const volatile T * );
 …
 signed int ?<?( _Bool, _Bool ),                                         ?<=?( _Bool, _Bool ),
            ?>?( _Bool, _Bool ),                                         ?>=?( _Bool, _Bool );
 signed int ?<?( char, char ),                           ?<=?( char, char ),
            ?>?( char, char ),                           ?>=?( char, char );
+signed int ?<?( char, char ),                                           ?<=?( char, char ),
+           ?>?( char, char ),                                           ?>=?( char, char );
 signed int ?<?( signed char, signed char ),                             ?<=?( signed char, signed char ),
            ?>?( signed char, signed char ),                             ?>=?( signed char, signed char );
 …
            ?>?( signed short, signed short ),                           ?>=?( signed short, signed short );
 signed int ?<?( unsigned short, unsigned short ),                       ?<=?( unsigned short, unsigned short ),
            ?>?( unsigned short, unsigned short ),                               ?>=?( unsigned short, unsigned short );
+           ?>?( unsigned short, unsigned short ),                       ?>=?( unsigned short, unsigned short );
 signed int ?<?( signed int, signed int ),                               ?<=?( signed int, signed int ),
            ?>?( signed int, signed int ),                               ?>=?( signed int, signed int );
 …
 forall( ftype FT ) FT *                 ?=?( FT * volatile &, zero_t );
 forall( dtype T | sized(T) ) T *                        ?+=?(                T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?+=?(                T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                ?+=?(                T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                ?+=?(                T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?+=?( const          T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?+=?( const          T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?+=?(       volatile T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?+=?(       volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *       ?+=?(       volatile T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *       ?+=?(       volatile T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?-=?(                T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?-=?(                T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                ?-=?(                T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                ?-=?(                T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?-=?( const          T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?-=?( const          T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?-=?(       volatile T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?-=?(       volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *       ?-=?(       volatile T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *       ?-=?(       volatile T * volatile &, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T *          &, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile &, ptrdiff_t );
 …
 signed long long int    ?=?( signed long long int &, signed long long int ),    ?=?( volatile signed long long int &, signed long long int );
 unsigned long long int  ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int );
 zero_t          ?=?( zero_t &, zero_t );
+zero_t                  ?=?( zero_t &, zero_t );
 one_t                   ?=?( one_t &, one_t );
 …
 signed long long int    ?+=?( signed long long int &, signed long long int ),   ?+=?( volatile signed long long int &, signed long long int );
 unsigned long long int  ?+=?( unsigned long long int &, unsigned long long int ), ?+=?( volatile unsigned long long int &, unsigned long long int );
+//signed int128         ?+=?( signed int128 &, signed int128 ),                 ?+=?( volatile signed int128 &, signed int128 );
+//unsigned int128               ?+=?( unsigned int128 &, unsigned int128 ),             ?+=?( volatile unsigned int128 &, unsigned int128 );
 _Bool                   ?-=?( _Bool &, _Bool ),                                 ?-=?( volatile _Bool &, _Bool );
 …
                         ?+=?( long double _Complex &, long double _Complex ), ?+=?( volatile long double _Complex &, long double _Complex ),
                         ?-=?( long double _Complex &, long double _Complex ), ?-=?( volatile long double _Complex &, long double _Complex );
 …
 forall( dtype DT ) void ^?{}( const volatile  DT *         &);
 void    ^?{}(               void *          &);
 void    ^?{}( const         void *          &);
 void    ^?{}(      volatile void *          &);
 void    ^?{}( const volatile void *         &);
+void ^?{}(                  void *          &);
+void ^?{}( const            void *          &);
+void ^?{}(         volatile void *          &);
+void ^?{}( const   volatile void *          &);
 // Local Variables: //

src/tests/.expect/32/KRfunctions.txt

-              r78315272
+              r3f7e12cb
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
 …
     struct S ___ret__2sS_1;
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
 …
     signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ___retval_f10__PFPi_ii__1;
+}
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{

src/tests/.expect/32/attributes.txt

-              r78315272
+              r3f7e12cb
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 __attribute__ ((unused)) struct Agn1;
 …
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
     return ((struct Agn2 )___ret__5sAgn2_1);
+    ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
+    return ___ret__5sAgn2_1;
+}
 enum __attribute__ ((unused)) __anonymous1 {
 …
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1);
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1);
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1);
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1);
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1);
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object1);
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object2, signed int *__f9__Pi_1);
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
     return ((struct Fdl )___ret__4sFdl_1);
+    ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__R4sFdl_1)));
+    return ___ret__4sFdl_1;
+}
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object3){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object4, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 …
     __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
 __attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object5))[];
 __attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
+__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object8);
+}
 signed int __vtr__Fi___1(){
 …
 signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
 signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned int )5)]));
+signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
+signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
 signed int __ad__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_ad__i_1;
 …
         struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+        ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__R13s__anonymous4_2)));
+        return ___ret__13s__anonymous4_2;
+    }
     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
 …
+    }
     inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
+    }
     inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
 …
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         enum __anonymous5 ___ret__13e__anonymous5_2;
+        ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
+        return ___ret__13e__anonymous5_2;
+    }
     ((void)sizeof(enum __anonymous5 ));
+}
 signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
 signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
 signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
 struct Vad {
     __attribute__ ((unused)) signed int __anonymous_object28;
     __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned int )10)];
     __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
+    __attribute__ ((unused)) signed int __anonymous_object32;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object33;
+    __attribute__ ((unused,unused)) signed int __anonymous_object34[((unsigned int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 …
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object36);
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object37, signed int *__anonymous_object38);
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object39, signed int *__anonymous_object40, signed int __anonymous_object41[((unsigned int )10)]);
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object42, signed int *__anonymous_object43, signed int __anonymous_object44[((unsigned int )10)], signed int (*__anonymous_object45)());
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index0 = 0;
+        for (;(_index0<10);((void)(++_index0))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index0])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
+        signed int _index1 = 0;
+        for (;(_index1<10);((void)(++_index1))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index1])))=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
+        signed int _index2 = (10-1);
+        for (;(_index2>=0);((void)(--_index2))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index2])))) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ^?{} */);
+}
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
     struct Vad ___ret__4sVad_1;
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    return ((struct Vad )___ret__4sVad_1);
+}
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
+    {
+        signed int _index3 = 0;
+        for (;(_index3<10);((void)(++_index3))) {
+            ((void)((*___dst__R4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__R4sVad_1)));
+    return ___ret__4sVad_1;
+}
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object46){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index4 = 0;
+        for (;(_index4<10);((void)(++_index4))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index4])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object47, signed int *__anonymous_object48){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
+        signed int _index5 = 0;
+        for (;(_index5<10);((void)(++_index5))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index5])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object49, signed int *__anonymous_object50, signed int __anonymous_object51[((unsigned int )10)]){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
+        signed int _index6 = 0;
+        for (;(_index6<10);((void)(++_index6))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index6])))=__anonymous_object51[_index6]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object52, signed int *__anonymous_object53, signed int __anonymous_object54[((unsigned int )10)], signed int (*__anonymous_object55)()){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
+        signed int _index7 = 0;
+        for (;(_index7<10);((void)(++_index7))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[_index7])))=__anonymous_object54[_index7]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/.expect/32/declarationSpecifier.txt

-              r78315272
+              r3f7e12cb
 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+    ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__R13s__anonymous1_1)));
+    return ___ret__13s__anonymous1_1;
+}
 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+    ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__R13s__anonymous2_1)));
+    return ___ret__13s__anonymous2_1;
+}
 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+    ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__R13s__anonymous3_1)));
+    return ___ret__13s__anonymous3_1;
+}
 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+    ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__R13s__anonymous4_1)));
+    return ___ret__13s__anonymous4_1;
+}
 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+    ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__R13s__anonymous5_1)));
+    return ___ret__13s__anonymous5_1;
+}
 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+    ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__R13s__anonymous6_1)));
+    return ___ret__13s__anonymous6_1;
+}
 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+    ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__R13s__anonymous7_1)));
+    return ___ret__13s__anonymous7_1;
+}
 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+    ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__R13s__anonymous8_1)));
+    return ___ret__13s__anonymous8_1;
+}
 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+    ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__R13s__anonymous9_1)));
+    return ___ret__13s__anonymous9_1;
+}
 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+    ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__R14s__anonymous10_1)));
+    return ___ret__14s__anonymous10_1;
+}
 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+    ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__R14s__anonymous11_1)));
+    return ___ret__14s__anonymous11_1;
+}
 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+    ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__R14s__anonymous12_1)));
+    return ___ret__14s__anonymous12_1;
+}
 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+    ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__R14s__anonymous13_1)));
+    return ___ret__14s__anonymous13_1;
+}
 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+    ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__R14s__anonymous14_1)));
+    return ___ret__14s__anonymous14_1;
+}
 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+    ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__R14s__anonymous15_1)));
+    return ___ret__14s__anonymous15_1;
+}
 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+    ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__R14s__anonymous16_1)));
+    return ___ret__14s__anonymous16_1;
+}
 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+    ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__R14s__anonymous17_1)));
+    return ___ret__14s__anonymous17_1;
+}
 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+    ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__R14s__anonymous18_1)));
+    return ___ret__14s__anonymous18_1;
+}
 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+    ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__R14s__anonymous19_1)));
+    return ___ret__14s__anonymous19_1;
+}
 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+    ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__R14s__anonymous20_1)));
+    return ___ret__14s__anonymous20_1;
+}
 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+    ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__R14s__anonymous21_1)));
+    return ___ret__14s__anonymous21_1;
+}
 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+    ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__R14s__anonymous22_1)));
+    return ___ret__14s__anonymous22_1;
+}
 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+    ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__R14s__anonymous23_1)));
+    return ___ret__14s__anonymous23_1;
+}
 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
 …
     __attribute__ ((unused)) signed int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/32/extension.txt

-              r78315272
+              r3f7e12cb
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1);
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1);
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__a__i_1) /* ?{} */);
 …
     ((void)((*___dst__R2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
 …
     __extension__ signed int __c__i_1;
 };
+static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1);
 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 …
     union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
     return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
+    ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__R2uU_1)));
+    return ___ret__2uU_1;
+}
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
+}
 __extension__ enum E {
 …
         __extension__ signed int *__z__Pi_2;
     };
+    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
+    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
+    }
+    inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */);
+    }
+    inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        struct S ___ret__2sS_2;
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2, signed int *__z__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
+    }
+    signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);

src/tests/.expect/32/gccExtensions.txt

-              r78315272
+              r3f7e12cb
         ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
         return ((struct S )___ret__2sS_2);
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
 …
         ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+    }
     signed int __i__i_2 = ((signed int )__extension__ 3);
+    signed int __i__i_2 = __extension__ 3;
     __extension__ signed int __a__i_2;
     __extension__ signed int __b__i_2;
 …
         struct s2 ___ret__3ss2_2;
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
         return ((struct s2 )___ret__3ss2_2);
+        ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__R3ss2_2)));
+        return ___ret__3ss2_2;
+    }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
 …
         struct s3 ___ret__3ss3_2;
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
         return ((struct s3 )___ret__3ss3_2);
+        ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__R3ss3_2)));
+        return ___ret__3ss3_2;
+    }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
 …
         struct s4 ___ret__3ss4_2;
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
         return ((struct s4 )___ret__3ss4_2);
+        ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__R3ss4_2)));
+        return ___ret__3ss4_2;
+    }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
 …
     signed int __m3__A0A0i_2[((unsigned int )10)][((unsigned int )10)];
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}

src/tests/.expect/32/literals.txt

-              r78315272
+              r3f7e12cb
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
 extern signed int printf(const char *__restrict __format, ...);
 void __for_each__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
 void __for_each_reverse__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
+void __for_each__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
+void __for_each_reverse__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object103), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, char __anonymous_object109);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object131), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, signed char __anonymous_object137);
 …
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCl__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, const signed long int *__anonymous_object669);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object670), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object672, _Bool __anonymous_object673), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object675, const char *__anonymous_object676), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object677), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object678, _Bool __anonymous_object679), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object680), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object685, const char *__anonymous_object686), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object687), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object688, const char *__anonymous_object689), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object692, const char *__anonymous_object693, unsigned long int __anonymous_object694), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object695, const char *__fmt__PCc_1, ...), void *__anonymous_object696, const void *__anonymous_object697);
 void *___operator_bitor__A1_1_0_1____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_bitor__PFPd0_Pd0t1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_bitor__PFPd0_Pd0tVARGS2__FPd0_Pd0t1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object698)(), void *__anonymous_object699, void *__anonymous_object700), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object701)(), void *__anonymous_object702, void *__anonymous_object703), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object704)(), void *__anonymous_object705, void *__anonymous_object706), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object707)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object708, void *__anonymous_object709), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object710, void *__anonymous_object711), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object713, void *__anonymous_object714), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object715), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype2tT__1)(void *__anonymous_object716, void *__anonymous_object717), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object720, _Bool __anonymous_object721), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object722), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object723, const char *__anonymous_object724), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object726, _Bool __anonymous_object727), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object728), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object733, const char *__anonymous_object734), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object736, const char *__anonymous_object737), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object740, const char *__anonymous_object741, unsigned long int __anonymous_object742), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object743, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype7tParams__1)(void *__anonymous_object744, void *__anonymous_object745), void *__os__P7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
+void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFPd0_Pd0d1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_bitor__PFPd0_Pd0tVARGS2__FPd0_Pd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object698)(), void *__anonymous_object699, void *__anonymous_object700), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object701)(), void *__anonymous_object702, void *__anonymous_object703), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object704)(), void *__anonymous_object705, void *__anonymous_object706), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object707)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object708, void *__anonymous_object709), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object710, void *__anonymous_object711), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object713, void *__anonymous_object714), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object715), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype2tT__1)(void *__anonymous_object716, void *__anonymous_object717), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object720, _Bool __anonymous_object721), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object722), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object723, const char *__anonymous_object724), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object726, _Bool __anonymous_object727), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object728), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object733, const char *__anonymous_object734), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object736, const char *__anonymous_object737), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object740, const char *__anonymous_object741, unsigned long int __anonymous_object742), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object743, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype7tParams__1)(void *__anonymous_object744, void *__anonymous_object745), void *__os__P7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772, void *(*__anonymous_object773)(void *__anonymous_object774));
 void *__endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object775), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object776), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object777, _Bool __anonymous_object778), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object779), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object780, const char *__anonymous_object781), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object782), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object783, _Bool __anonymous_object784), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object788), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object789), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object790, const char *__anonymous_object791), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object792), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object793, const char *__anonymous_object794), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object795), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object796), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object797, const char *__anonymous_object798, unsigned long int __anonymous_object799), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object800, const char *__fmt__PCc_1, ...), void *__anonymous_object801);
 …
 void *__sepDisable__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object910), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object911), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object912, _Bool __anonymous_object913), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object914), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object915, const char *__anonymous_object916), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object917), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object918, _Bool __anonymous_object919), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object920), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object921), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object922), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object923), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object924), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object925, const char *__anonymous_object926), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object927), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object928, const char *__anonymous_object929), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object930), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object931), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object932, const char *__anonymous_object933, unsigned long int __anonymous_object934), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object935, const char *__fmt__PCc_1, ...), void *__anonymous_object936);
 void *__sepEnable__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object937), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object939, _Bool __anonymous_object940), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object941), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object942, const char *__anonymous_object943), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object944), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object945, _Bool __anonymous_object946), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object947), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object952, const char *__anonymous_object953), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object954), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object955, const char *__anonymous_object956), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object957), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object959, const char *__anonymous_object960, unsigned long int __anonymous_object961), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object962, const char *__fmt__PCc_1, ...), void *__anonymous_object963);
 void __write__A2_1_0_0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_bitor__PFPd0_Pd0t1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFt2_Rt2t2____constructor__PF_Rt2____constructor__PF_Rt2t2____destructor__PF_Rt2____operator_preincr__PFt2_Rt2____operator_predecr__PFt2_Rt2____operator_equal__PFi_t2t2____operator_notequal__PFi_t2t2____operator_deref__PFRt1_t2__F_t2t2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object964)(), void *__anonymous_object965), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object966)(), void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object969)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object970), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object971)(), void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object974)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object975, void *__anonymous_object976), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object977)(), void *__anonymous_object978, void *__anonymous_object979), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object980)(), void *__anonymous_object981, void *__anonymous_object982), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object983)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object984, void *__anonymous_object985), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object986, void *__anonymous_object987), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object988), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object989, void *__anonymous_object990), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object991), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object992, void *__anonymous_object993), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object994), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object995), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object996, _Bool __anonymous_object997), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object998), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object999, const char *__anonymous_object1000), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1002, _Bool __anonymous_object1003), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1004), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1005), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1009, const char *__anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1015), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1016, const char *__anonymous_object1017, unsigned long int __anonymous_object1018), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1019, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1023, void *__anonymous_object1024), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1025), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1026), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1028, void *__anonymous_object1029), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1030, void *__anonymous_object1031), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1032), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
 void __write_reverse__A2_1_0_0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_bitor__PFPd0_Pd0t1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFt2_Rt2t2____constructor__PF_Rt2____constructor__PF_Rt2t2____destructor__PF_Rt2____operator_preincr__PFt2_Rt2____operator_predecr__PFt2_Rt2____operator_equal__PFi_t2t2____operator_notequal__PFi_t2t2____operator_deref__PFRt1_t2__F_t2t2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1033)(), void *__anonymous_object1034), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1035)(), void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1038)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1039), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1040)(), void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1043)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1044, void *__anonymous_object1045), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1046)(), void *__anonymous_object1047, void *__anonymous_object1048), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1049)(), void *__anonymous_object1050, void *__anonymous_object1051), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1052)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1053, void *__anonymous_object1054), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1055, void *__anonymous_object1056), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1060), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object1061, void *__anonymous_object1062), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object1063), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object1064), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object1065, _Bool __anonymous_object1066), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object1068, const char *__anonymous_object1069), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1070), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1071, _Bool __anonymous_object1072), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1073), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1074), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1075), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1076), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1078, const char *__anonymous_object1079), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1080), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1081, const char *__anonymous_object1082), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1083), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1084), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1085, const char *__anonymous_object1086, unsigned long int __anonymous_object1087), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1088, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1092, void *__anonymous_object1093), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1094), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1095), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1097, void *__anonymous_object1098), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1099, void *__anonymous_object1100), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1101), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
+void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFPd0_Pd0d1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object964)(), void *__anonymous_object965), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object966)(), void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object969)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object970), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object971)(), void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object974)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object975, void *__anonymous_object976), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object977)(), void *__anonymous_object978, void *__anonymous_object979), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object980)(), void *__anonymous_object981, void *__anonymous_object982), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object983)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object984, void *__anonymous_object985), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object986, void *__anonymous_object987), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object988), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object989, void *__anonymous_object990), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object991), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object992, void *__anonymous_object993), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object994), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object995), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object996, _Bool __anonymous_object997), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object998), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object999, const char *__anonymous_object1000), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1002, _Bool __anonymous_object1003), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1004), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1005), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1009, const char *__anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1015), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1016, const char *__anonymous_object1017, unsigned long int __anonymous_object1018), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1019, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1023, void *__anonymous_object1024), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1025), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1026), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1028, void *__anonymous_object1029), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1030, void *__anonymous_object1031), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1032), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
+void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFPd0_Pd0d1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1033)(), void *__anonymous_object1034), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1035)(), void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1038)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1039), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1040)(), void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1043)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1044, void *__anonymous_object1045), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1046)(), void *__anonymous_object1047, void *__anonymous_object1048), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1049)(), void *__anonymous_object1050, void *__anonymous_object1051), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1052)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1053, void *__anonymous_object1054), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1055, void *__anonymous_object1056), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1060), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object1061, void *__anonymous_object1062), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object1063), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object1064), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object1065, _Bool __anonymous_object1066), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object1068, const char *__anonymous_object1069), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1070), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1071, _Bool __anonymous_object1072), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1073), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1074), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1075), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1076), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1078, const char *__anonymous_object1079), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1080), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1081, const char *__anonymous_object1082), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1083), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1084), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1085, const char *__anonymous_object1086, unsigned long int __anonymous_object1087), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1088, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1092, void *__anonymous_object1093), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1094), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1095), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1097, void *__anonymous_object1098), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1099, void *__anonymous_object1100), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1101), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1102), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1103), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1104, char *__anonymous_object1105, unsigned long int __anonymous_object1106), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1107, char __anonymous_object1108), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1109, const char *__fmt__PCc_1, ...), void *__anonymous_object1110, char *__anonymous_object1111);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1112), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1113), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1114, char *__anonymous_object1115, unsigned long int __anonymous_object1116), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1117, char __anonymous_object1118), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1119, const char *__fmt__PCc_1, ...), void *__anonymous_object1120, signed char *__anonymous_object1121);
 …
 static inline void ___destructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1);
 static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1);
 static inline void ___constructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1) /* ?{} */);
 …
     struct _Istream_cstrUC ___ret__16s_Istream_cstrUC_1;
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
     ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), ___src__16s_Istream_cstrUC_1));
     return ((struct _Istream_cstrUC )___ret__16s_Istream_cstrUC_1);
+    ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), (*___dst__R16s_Istream_cstrUC_1)));
+    return ___ret__16s_Istream_cstrUC_1;
+}
 static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1){
 …
 static inline void ___destructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1);
 static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1);
 static inline void ___constructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1){
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1) /* ?{} */);
 …
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1));
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
     ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), ___src__15s_Istream_cstrC_1));
     return ((struct _Istream_cstrC )___ret__15s_Istream_cstrC_1);
+    ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), (*___dst__R15s_Istream_cstrC_1)));
+    return ___ret__15s_Istream_cstrC_1;
+}
 static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1){
 …
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1285), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
 enum __anonymous0 {
     __sepSize__C13e__anonymous0_1 = ((signed int )16),
+    __sepSize__C13e__anonymous0_1 = 16,
 };
 struct ofstream {
 …
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
 static inline struct ofstream ___operator_assign__F9sofstream_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1);
+static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]);
 static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
     ((void)((*___dst__R9sofstream_1).__file__Pv_1) /* ?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index0 = ((signed int )0);
+        signed int _index0 = 0;
         for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index0])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index1 = ((signed int )0);
+    {
+        signed int _index1 = 0;
         for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index1])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index2 = ((signed int )0);
+        signed int _index2 = 0;
         for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index2])))=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
 …
+    }
+    {
+        signed int _index3 = ((signed int )0);
+    {
+        signed int _index3 = 0;
         for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index3])))=___src__9sofstream_1.__tupleSeparator__A0c_1[_index3]) /* ?{} */);
 …
+    }
+}
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
+    {
         signed int _index4 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+        signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index4>=0);((void)(--_index4))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index4])))) /* ^?{} */);
 …
+    }
+    {
+        signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+    {
+        signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index5>=0);((void)(--_index5))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index5])))) /* ^?{} */);
 …
+    }
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ^?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    {
         signed int _index6 = ((signed int )0);
+        signed int _index6 = 0;
         for (;(_index6<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index6))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index6]=___src__9sofstream_1.__separator__A0c_1[_index6]));
 …
+    {
         signed int _index7 = ((signed int )0);
+        signed int _index7 = 0;
         for (;(_index7<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index7))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index7]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index7]));
 …
+    }
     ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), ___src__9sofstream_1));
     return ((struct ofstream )___ret__9sofstream_1);
+    ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), (*___dst__R9sofstream_1)));
+    return ___ret__9sofstream_1;
+}
 static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index8 = ((signed int )0);
+        signed int _index8 = 0;
         for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index8])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index9 = ((signed int )0);
+    {
+        signed int _index9 = 0;
         for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index9])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index10 = ((signed int )0);
+        signed int _index10 = 0;
         for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index10])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index11 = ((signed int )0);
+    {
+        signed int _index11 = 0;
         for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index11])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index12 = ((signed int )0);
+        signed int _index12 = 0;
         for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index12])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index13 = ((signed int )0);
+    {
+        signed int _index13 = 0;
         for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index13])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index14 = ((signed int )0);
+        signed int _index14 = 0;
         for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index14])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index15 = ((signed int )0);
+    {
+        signed int _index15 = 0;
         for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index15])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index16 = ((signed int )0);
+        signed int _index16 = 0;
         for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index16])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index17 = ((signed int )0);
+    {
+        signed int _index17 = 0;
         for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index17])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index18 = ((signed int )0);
+        signed int _index18 = 0;
         for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index18])))=__separator__A0c_1[_index18]) /* ?{} */);
 …
+    }
+    {
+        signed int _index19 = ((signed int )0);
+    {
+        signed int _index19 = 0;
         for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index19])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index20 = ((signed int )0);
+        signed int _index20 = 0;
         for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[_index20])))=__separator__A0c_1[_index20]) /* ?{} */);
 …
+    }
+    {
+        signed int _index21 = ((signed int )0);
+    {
+        signed int _index21 = 0;
         for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21])))=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
 …
+    }
+}
 _Bool __sepPrt__Fb_P9sofstream__1(struct ofstream *__anonymous_object1294);
 …
 static inline void ___destructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1);
 static inline struct ifstream ___operator_assign__F9sifstream_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1);
 static inline void ___constructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1) /* ?{} */);
 …
     struct ifstream ___ret__9sifstream_1;
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
     ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), ___src__9sifstream_1));
     return ((struct ifstream )___ret__9sifstream_1);
+    ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), (*___dst__R9sifstream_1)));
+    return ___ret__9sifstream_1;
+}
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
 …
     struct ofstream *_tmp_cp_ret2;
     __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1322))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1323))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1324, _Bool __anonymous_object1325))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1326))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1327, const char *__anonymous_object1328))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1329))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1330, _Bool __anonymous_object1331))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1332))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1333))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1335))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1336))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1337, const char *__anonymous_object1338))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1339))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1340, const char *__anonymous_object1341))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1342))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1343))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1344, const char *__anonymous_object1345, unsigned long int __anonymous_object1346))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1347, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1348))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1349))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1350, _Bool __anonymous_object1351))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1352))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1353, const char *__anonymous_object1354))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1355))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1356, _Bool __anonymous_object1357))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1358))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1359))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1362))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1363, const char *__anonymous_object1364))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1365))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1366, const char *__anonymous_object1367))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1368))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1369))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1370, const char *__anonymous_object1371, unsigned long int __anonymous_object1372))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1373, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret1=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(((_Bool (*)(void *__anonymous_object1374))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1375))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1376, _Bool __anonymous_object1377))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1378))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1379, const char *__anonymous_object1380))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1381))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1382, _Bool __anonymous_object1383))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1384))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1385))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1388))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1389, const char *__anonymous_object1390))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1391))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1392, const char *__anonymous_object1393))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1394))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1395))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1396, const char *__anonymous_object1397, unsigned long int __anonymous_object1398))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1399, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret0=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1400))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1401))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1402, _Bool __anonymous_object1403))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1404))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1405, const char *__anonymous_object1406))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1407))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1408, _Bool __anonymous_object1409))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1410))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1411))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1414))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1415, const char *__anonymous_object1416))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1417))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1418, const char *__anonymous_object1419))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1420))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1421))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1422, const char *__anonymous_object1423, unsigned long int __anonymous_object1424))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1425, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "char "))) , _tmp_cp_ret0), __v__c_1))) , _tmp_cp_ret1), ((void *(*)(void *__anonymous_object1426))(&_thunk0))))) , _tmp_cp_ret2));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1322))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1323))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1324, _Bool __anonymous_object1325))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1326))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1327, const char *__anonymous_object1328))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1329))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1330, _Bool __anonymous_object1331))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1332))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1333))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1335))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1336))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1337, const char *__anonymous_object1338))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1339))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1340, const char *__anonymous_object1341))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1342))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1343))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1344, const char *__anonymous_object1345, unsigned long int __anonymous_object1346))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1347, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1348))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1349))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1350, _Bool __anonymous_object1351))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1352))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1353, const char *__anonymous_object1354))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1355))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1356, _Bool __anonymous_object1357))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1358))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1359))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1362))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1363, const char *__anonymous_object1364))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1365))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1366, const char *__anonymous_object1367))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1368))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1369))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1370, const char *__anonymous_object1371, unsigned long int __anonymous_object1372))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1373, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(((_Bool (*)(void *__anonymous_object1374))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1375))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1376, _Bool __anonymous_object1377))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1378))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1379, const char *__anonymous_object1380))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1381))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1382, _Bool __anonymous_object1383))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1384))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1385))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1388))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1389, const char *__anonymous_object1390))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1391))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1392, const char *__anonymous_object1393))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1394))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1395))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1396, const char *__anonymous_object1397, unsigned long int __anonymous_object1398))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1399, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1400))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1401))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1402, _Bool __anonymous_object1403))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1404))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1405, const char *__anonymous_object1406))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1407))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1408, _Bool __anonymous_object1409))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1410))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1411))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1414))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1415, const char *__anonymous_object1416))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1417))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1418, const char *__anonymous_object1419))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1420))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1421))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1422, const char *__anonymous_object1423, unsigned long int __anonymous_object1424))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1425, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "char "))) , _tmp_cp_ret0)), __v__c_1))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1426))(&_thunk0))))) , _tmp_cp_ret2));
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     ((void)(_tmp_cp_ret1) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret5;
     __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1453))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1454))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1455, _Bool __anonymous_object1456))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1457))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1458, const char *__anonymous_object1459))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1460))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1463))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1464))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1467))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1468, const char *__anonymous_object1469))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1470))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1471, const char *__anonymous_object1472))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1473))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1474))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1475, const char *__anonymous_object1476, unsigned long int __anonymous_object1477))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1478, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(((_Bool (*)(void *__anonymous_object1479))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1480))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1481, _Bool __anonymous_object1482))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1483))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1484, const char *__anonymous_object1485))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1486))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1489))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1490))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1493))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1494, const char *__anonymous_object1495))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1496))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1497, const char *__anonymous_object1498))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1499))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1500))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1501, const char *__anonymous_object1502, unsigned long int __anonymous_object1503))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1504, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1505))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1506))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1507, _Bool __anonymous_object1508))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1509))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1510, const char *__anonymous_object1511))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1512))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1515))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1516))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1519))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1520, const char *__anonymous_object1521))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1522))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1523, const char *__anonymous_object1524))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1525))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1526))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1527, const char *__anonymous_object1528, unsigned long int __anonymous_object1529))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1530, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed char "))) , _tmp_cp_ret3), __v__Sc_1))) , _tmp_cp_ret4), ((void *(*)(void *__anonymous_object1531))(&_thunk1))))) , _tmp_cp_ret5));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1453))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1454))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1455, _Bool __anonymous_object1456))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1457))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1458, const char *__anonymous_object1459))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1460))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1463))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1464))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1467))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1468, const char *__anonymous_object1469))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1470))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1471, const char *__anonymous_object1472))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1473))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1474))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1475, const char *__anonymous_object1476, unsigned long int __anonymous_object1477))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1478, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(((_Bool (*)(void *__anonymous_object1479))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1480))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1481, _Bool __anonymous_object1482))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1483))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1484, const char *__anonymous_object1485))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1486))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1489))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1490))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1493))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1494, const char *__anonymous_object1495))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1496))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1497, const char *__anonymous_object1498))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1499))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1500))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1501, const char *__anonymous_object1502, unsigned long int __anonymous_object1503))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1504, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1505))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1506))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1507, _Bool __anonymous_object1508))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1509))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1510, const char *__anonymous_object1511))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1512))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1515))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1516))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1519))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1520, const char *__anonymous_object1521))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1522))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1523, const char *__anonymous_object1524))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1525))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1526))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1527, const char *__anonymous_object1528, unsigned long int __anonymous_object1529))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1530, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "signed char "))) , _tmp_cp_ret3)), __v__Sc_1))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1531))(&_thunk1))))) , _tmp_cp_ret5));
     ((void)(_tmp_cp_ret3) /* ^?{} */);
     ((void)(_tmp_cp_ret4) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret8;
     __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1558))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1559))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1560, _Bool __anonymous_object1561))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1562))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1563, const char *__anonymous_object1564))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1565))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1568))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1569))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1572))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1573, const char *__anonymous_object1574))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1575))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1576, const char *__anonymous_object1577))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1578))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1579))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1580, const char *__anonymous_object1581, unsigned long int __anonymous_object1582))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1583, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Uc__1(((_Bool (*)(void *__anonymous_object1584))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1585))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1586, _Bool __anonymous_object1587))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1588))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1589, const char *__anonymous_object1590))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1591))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1594))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1595))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1598))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1599, const char *__anonymous_object1600))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1601))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1602, const char *__anonymous_object1603))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1604))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1605))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1606, const char *__anonymous_object1607, unsigned long int __anonymous_object1608))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1609, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1610))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1611))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1612, _Bool __anonymous_object1613))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1614))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1615, const char *__anonymous_object1616))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1617))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1620))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1621))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1624))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1625, const char *__anonymous_object1626))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1627))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1628, const char *__anonymous_object1629))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1630))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1631))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1632, const char *__anonymous_object1633, unsigned long int __anonymous_object1634))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1635, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned char "))) , _tmp_cp_ret6), __v__Uc_1))) , _tmp_cp_ret7), ((void *(*)(void *__anonymous_object1636))(&_thunk2))))) , _tmp_cp_ret8));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1558))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1559))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1560, _Bool __anonymous_object1561))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1562))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1563, const char *__anonymous_object1564))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1565))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1568))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1569))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1572))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1573, const char *__anonymous_object1574))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1575))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1576, const char *__anonymous_object1577))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1578))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1579))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1580, const char *__anonymous_object1581, unsigned long int __anonymous_object1582))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1583, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Uc__1(((_Bool (*)(void *__anonymous_object1584))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1585))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1586, _Bool __anonymous_object1587))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1588))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1589, const char *__anonymous_object1590))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1591))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1594))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1595))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1598))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1599, const char *__anonymous_object1600))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1601))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1602, const char *__anonymous_object1603))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1604))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1605))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1606, const char *__anonymous_object1607, unsigned long int __anonymous_object1608))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1609, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1610))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1611))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1612, _Bool __anonymous_object1613))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1614))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1615, const char *__anonymous_object1616))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1617))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1620))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1621))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1624))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1625, const char *__anonymous_object1626))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1627))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1628, const char *__anonymous_object1629))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1630))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1631))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1632, const char *__anonymous_object1633, unsigned long int __anonymous_object1634))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1635, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "unsigned char "))) , _tmp_cp_ret6)), __v__Uc_1))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1636))(&_thunk2))))) , _tmp_cp_ret8));
     ((void)(_tmp_cp_ret6) /* ^?{} */);
     ((void)(_tmp_cp_ret7) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret11;
     __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1663))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1664))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1665, _Bool __anonymous_object1666))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1667))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1668, const char *__anonymous_object1669))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1670))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1673))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1674))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1677))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1678, const char *__anonymous_object1679))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1680))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1681, const char *__anonymous_object1682))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1683))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1684))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1685, const char *__anonymous_object1686, unsigned long int __anonymous_object1687))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1688, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0s__1(((_Bool (*)(void *__anonymous_object1689))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1690))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1691, _Bool __anonymous_object1692))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1693))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1694, const char *__anonymous_object1695))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1696))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1699))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1700))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1703))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1704, const char *__anonymous_object1705))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1706))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1707, const char *__anonymous_object1708))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1709))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1710))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1711, const char *__anonymous_object1712, unsigned long int __anonymous_object1713))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1714, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1715))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1716))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1717, _Bool __anonymous_object1718))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1719))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1720, const char *__anonymous_object1721))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1722))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1725))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1726))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1729))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1730, const char *__anonymous_object1731))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1732))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1733, const char *__anonymous_object1734))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1735))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1736))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1737, const char *__anonymous_object1738, unsigned long int __anonymous_object1739))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1740, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed short int"))) , _tmp_cp_ret9), __v__s_1))) , _tmp_cp_ret10), ((void *(*)(void *__anonymous_object1741))(&_thunk3))))) , _tmp_cp_ret11));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1663))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1664))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1665, _Bool __anonymous_object1666))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1667))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1668, const char *__anonymous_object1669))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1670))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1673))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1674))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1677))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1678, const char *__anonymous_object1679))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1680))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1681, const char *__anonymous_object1682))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1683))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1684))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1685, const char *__anonymous_object1686, unsigned long int __anonymous_object1687))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1688, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0s__1(((_Bool (*)(void *__anonymous_object1689))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1690))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1691, _Bool __anonymous_object1692))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1693))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1694, const char *__anonymous_object1695))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1696))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1699))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1700))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1703))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1704, const char *__anonymous_object1705))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1706))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1707, const char *__anonymous_object1708))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1709))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1710))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1711, const char *__anonymous_object1712, unsigned long int __anonymous_object1713))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1714, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1715))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1716))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1717, _Bool __anonymous_object1718))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1719))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1720, const char *__anonymous_object1721))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1722))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1725))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1726))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1729))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1730, const char *__anonymous_object1731))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1732))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1733, const char *__anonymous_object1734))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1735))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1736))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1737, const char *__anonymous_object1738, unsigned long int __anonymous_object1739))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1740, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "signed short int"))) , _tmp_cp_ret9)), __v__s_1))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1741))(&_thunk3))))) , _tmp_cp_ret11));
     ((void)(_tmp_cp_ret9) /* ^?{} */);
     ((void)(_tmp_cp_ret10) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret14;
     __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1768))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1769))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1770, _Bool __anonymous_object1771))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1772))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1773, const char *__anonymous_object1774))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1775))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1778))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1779))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1782))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1783, const char *__anonymous_object1784))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1785))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1786, const char *__anonymous_object1787))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1788))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1789))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1790, const char *__anonymous_object1791, unsigned long int __anonymous_object1792))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1793, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Us__1(((_Bool (*)(void *__anonymous_object1794))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1795))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1796, _Bool __anonymous_object1797))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1798))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1799, const char *__anonymous_object1800))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1801))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1804))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1805))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1808))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1809, const char *__anonymous_object1810))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1811))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1812, const char *__anonymous_object1813))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1814))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1815))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1816, const char *__anonymous_object1817, unsigned long int __anonymous_object1818))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1819, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1820))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1821))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1822, _Bool __anonymous_object1823))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1824))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1825, const char *__anonymous_object1826))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1827))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1830))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1831))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1834))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1835, const char *__anonymous_object1836))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1837))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1838, const char *__anonymous_object1839))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1840))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1841))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1842, const char *__anonymous_object1843, unsigned long int __anonymous_object1844))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1845, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned short int"))) , _tmp_cp_ret12), __v__Us_1))) , _tmp_cp_ret13), ((void *(*)(void *__anonymous_object1846))(&_thunk4))))) , _tmp_cp_ret14));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1768))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1769))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1770, _Bool __anonymous_object1771))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1772))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1773, const char *__anonymous_object1774))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1775))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1778))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1779))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1782))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1783, const char *__anonymous_object1784))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1785))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1786, const char *__anonymous_object1787))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1788))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1789))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1790, const char *__anonymous_object1791, unsigned long int __anonymous_object1792))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1793, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Us__1(((_Bool (*)(void *__anonymous_object1794))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1795))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1796, _Bool __anonymous_object1797))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1798))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1799, const char *__anonymous_object1800))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1801))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1804))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1805))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1808))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1809, const char *__anonymous_object1810))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1811))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1812, const char *__anonymous_object1813))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1814))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1815))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1816, const char *__anonymous_object1817, unsigned long int __anonymous_object1818))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1819, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1820))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1821))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1822, _Bool __anonymous_object1823))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1824))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1825, const char *__anonymous_object1826))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1827))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1830))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1831))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1834))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1835, const char *__anonymous_object1836))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1837))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1838, const char *__anonymous_object1839))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1840))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1841))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1842, const char *__anonymous_object1843, unsigned long int __anonymous_object1844))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1845, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "unsigned short int"))) , _tmp_cp_ret12)), __v__Us_1))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1846))(&_thunk4))))) , _tmp_cp_ret14));
     ((void)(_tmp_cp_ret12) /* ^?{} */);
     ((void)(_tmp_cp_ret13) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret17;
     __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1873))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1874))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1875, _Bool __anonymous_object1876))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1877))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1878, const char *__anonymous_object1879))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1880))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1883))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1884))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1887))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1888, const char *__anonymous_object1889))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1890))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1891, const char *__anonymous_object1892))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1893))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1894))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1895, const char *__anonymous_object1896, unsigned long int __anonymous_object1897))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1898, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Ui__1(((_Bool (*)(void *__anonymous_object1899))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1900))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1901, _Bool __anonymous_object1902))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1903))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1904, const char *__anonymous_object1905))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1906))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1909))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1910))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1913))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1914, const char *__anonymous_object1915))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1916))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1917, const char *__anonymous_object1918))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1919))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1920))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1921, const char *__anonymous_object1922, unsigned long int __anonymous_object1923))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1924, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1925))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1926))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1927, _Bool __anonymous_object1928))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1929))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1930, const char *__anonymous_object1931))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1932))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1935))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1936))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1939))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1940, const char *__anonymous_object1941))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1942))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1943, const char *__anonymous_object1944))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1945))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1946))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1947, const char *__anonymous_object1948, unsigned long int __anonymous_object1949))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1950, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "size_t"))) , _tmp_cp_ret15), __v__Ui_1))) , _tmp_cp_ret16), ((void *(*)(void *__anonymous_object1951))(&_thunk5))))) , _tmp_cp_ret17));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1873))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1874))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1875, _Bool __anonymous_object1876))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1877))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1878, const char *__anonymous_object1879))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1880))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1883))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1884))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1887))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1888, const char *__anonymous_object1889))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1890))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1891, const char *__anonymous_object1892))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1893))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1894))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1895, const char *__anonymous_object1896, unsigned long int __anonymous_object1897))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1898, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Ui__1(((_Bool (*)(void *__anonymous_object1899))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1900))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1901, _Bool __anonymous_object1902))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1903))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1904, const char *__anonymous_object1905))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1906))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1909))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1910))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1913))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1914, const char *__anonymous_object1915))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1916))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1917, const char *__anonymous_object1918))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1919))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1920))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1921, const char *__anonymous_object1922, unsigned long int __anonymous_object1923))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1924, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1925))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1926))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1927, _Bool __anonymous_object1928))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1929))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1930, const char *__anonymous_object1931))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1932))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1935))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1936))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1939))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1940, const char *__anonymous_object1941))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1942))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1943, const char *__anonymous_object1944))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1945))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1946))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1947, const char *__anonymous_object1948, unsigned long int __anonymous_object1949))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1950, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "size_t"))) , _tmp_cp_ret15)), __v__Ui_1))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1951))(&_thunk5))))) , _tmp_cp_ret17));
     ((void)(_tmp_cp_ret15) /* ^?{} */);
     ((void)(_tmp_cp_ret16) /* ^?{} */);
 …
     ((void)0123456789.e-09L);
     ((void)0123456789.e-09DL);
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
     ((void)(-0123456789.e-09l));
     ((void)(-0123456789.e-09F));
     ((void)(-0123456789.e-09L));
     ((void)(-0123456789.e-09DL));
+    ((void)(+0123456789.e-09));
+    ((void)(+0123456789.e-09f));
+    ((void)(+0123456789.e-09l));
+    ((void)(+0123456789.e-09F));
+    ((void)(+0123456789.e-09L));
+    ((void)(+0123456789.e-09DL));
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
 …
     ((void)0123456789.0123456789E-09L);
     ((void)0123456789.0123456789E-09DL);
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
     ((void)(-0123456789.0123456789E-09l));
     ((void)(-0123456789.0123456789E-09F));
     ((void)(-0123456789.0123456789E-09L));
     ((void)(-0123456789.0123456789E-09DL));
+    ((void)(+0123456789.0123456789E-09));
+    ((void)(+0123456789.0123456789E-09f));
+    ((void)(+0123456789.0123456789E-09l));
+    ((void)(+0123456789.0123456789E-09F));
+    ((void)(+0123456789.0123456789E-09L));
+    ((void)(+0123456789.0123456789E-09DL));
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
 …
     ((void)0x0123456789.p-09F);
     ((void)0x0123456789.p-09L);
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
     ((void)(-0x0123456789.p-09l));
     ((void)(-0x0123456789.p-09F));
     ((void)(-0x0123456789.p-09L));
+    ((void)(+0x0123456789.p-09));
+    ((void)(+0x0123456789.p-09f));
+    ((void)(+0x0123456789.p-09l));
+    ((void)(+0x0123456789.p-09F));
+    ((void)(+0x0123456789.p-09L));
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
 …
     ((void)0x.0123456789P-09F);
     ((void)0x.0123456789P-09L);
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
     ((void)(-0x.0123456789P-09l));
     ((void)(-0x.0123456789P-09F));
     ((void)(-0x.0123456789P-09L));
+    ((void)(+0x.0123456789P-09));
+    ((void)(+0x.0123456789P-09f));
+    ((void)(+0x.0123456789P-09l));
+    ((void)(+0x.0123456789P-09F));
+    ((void)(+0x.0123456789P-09L));
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
 …
     ((void)0X0123456789.0123456789P-09F);
     ((void)0X0123456789.0123456789P-09L);
+    ((void)(+0X0123456789.0123456789P-09));
+    ((void)(+0X0123456789.0123456789P-09f));
+    ((void)(+0X0123456789.0123456789P-09l));
+    ((void)(+0X0123456789.0123456789P-09F));
+    ((void)(+0X0123456789.0123456789P-09L));
     ((void)(-0X0123456789.0123456789P-09));
     ((void)(-0X0123456789.0123456789P-09f));
 …
     ((void)(-0X0123456789.0123456789P-09F));
     ((void)(-0X0123456789.0123456789P-09L));
+    ((void)(-0X0123456789.0123456789P-09));
+    ((void)(-0X0123456789.0123456789P-09f));
+    ((void)(-0X0123456789.0123456789P-09l));
+    ((void)(-0X0123456789.0123456789P-09F));
+    ((void)(-0X0123456789.0123456789P-09L));
+    ((void)((signed char )01234567));
+    ((void)((signed short int )01234567));
+    ((void)((signed int )01234567));
+    ((void)((signed long long int )01234567));
+    ((void)((__int128 )01234567));
+    ((void)((unsigned char )01234567u));
+    ((void)((signed short int )01234567u));
+    ((void)((unsigned int )01234567u));
+    ((void)((signed long long int )01234567u));
+    ((void)((__int128 )01234567u));
+    ((void)(+((signed int )((signed char )01234567))));
+    ((void)(+((signed int )((signed short int )01234567))));
+    ((void)(+((signed int )01234567)));
+    ((void)(+((signed long long int )01234567)));
+    ((void)(+((float )((__int128 )01234567))));
+    ((void)(+((signed int )((unsigned char )01234567u))));
+    ((void)(+((signed int )((signed short int )01234567u))));
+    ((void)(+((unsigned int )01234567u)));
+    ((void)(+((signed long long int )01234567u)));
+    ((void)(+((float )((__int128 )01234567u))));
+    ((void)(-((signed int )((signed char )01234567))));
+    ((void)(-((signed int )((signed short int )01234567))));
+    ((void)(-((signed int )01234567)));
+    ((void)(-((signed long long int )01234567)));
+    ((void)(-((float )((__int128 )01234567))));
+    ((void)(-((signed int )((unsigned char )01234567u))));
+    ((void)(-((signed int )((signed short int )01234567u))));
+    ((void)(-((unsigned int )01234567u)));
+    ((void)(-((signed long long int )01234567u)));
+    ((void)(-((float )((__int128 )01234567u))));
+    ((void)((signed char )1234567890));
+    ((void)((signed short int )1234567890));
+    ((void)((signed int )1234567890));
+    ((void)((signed long long int )1234567890));
+    ((void)((__int128 )1234567890));
+    ((void)((signed char )1234567890U));
+    ((void)((unsigned short int )1234567890U));
+    ((void)((signed int )1234567890U));
+    ((void)((unsigned long long int )1234567890u));
+    ((void)((unsigned __int128 )1234567890u));
+    ((void)(+((signed int )((signed char )1234567890))));
+    ((void)(+((signed int )((signed short int )1234567890))));
+    ((void)(+((signed int )1234567890)));
+    ((void)(+((signed long long int )1234567890)));
+    ((void)(+((float )((__int128 )1234567890))));
+    ((void)(+((signed int )((signed char )1234567890U))));
+    ((void)(+((signed int )((unsigned short int )1234567890U))));
+    ((void)(+((signed int )1234567890U)));
+    ((void)(+((unsigned long long int )1234567890u)));
+    ((void)(+((float )((unsigned __int128 )1234567890u))));
+    ((void)(-((signed int )((signed char )1234567890))));
+    ((void)(-((signed int )((signed short int )1234567890))));
+    ((void)(-((signed int )1234567890)));
+    ((void)(-((signed long long int )1234567890)));
+    ((void)(-((float )((__int128 )1234567890))));
+    ((void)(-((signed int )((signed char )1234567890U))));
+    ((void)(-((signed int )((unsigned short int )1234567890U))));
+    ((void)(-((signed int )1234567890U)));
+    ((void)(-((unsigned long long int )1234567890u)));
+    ((void)(-((float )((unsigned __int128 )1234567890u))));
+    ((void)((signed char )0x0123456789abcdef));
+    ((void)((signed short int )0x0123456789abcdef));
+    ((void)((signed int )0x0123456789abcdef));
+    ((void)((signed long long int )0x0123456789abcdef));
+    ((void)((signed char )0x0123456789abcdefu));
+    ((void)((unsigned short int )0x0123456789abcdefu));
+    ((void)((signed int )0x0123456789abcdefu));
+    ((void)((unsigned long long int )0x0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(+((signed int )0x0123456789abcdef)));
+    ((void)(+((signed long long int )0x0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(+((signed int )0x0123456789abcdefu)));
+    ((void)(+((unsigned long long int )0x0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(-((signed int )0x0123456789abcdef)));
+    ((void)(-((signed long long int )0x0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(-((signed int )0x0123456789abcdefu)));
+    ((void)(-((unsigned long long int )0x0123456789abcdefu)));
+    ((void)((signed char )0x0123456789ABCDEF));
+    ((void)((signed short int )0x0123456789ABCDEF));
+    ((void)((signed int )0x0123456789ABCDEF));
+    ((void)((signed long long int )0x0123456789ABCDEF));
+    ((void)((signed char )0x0123456789ABCDEFu));
+    ((void)((unsigned short int )0x0123456789ABCDEFu));
+    ((void)((signed int )0x0123456789ABCDEFu));
+    ((void)((unsigned long long int )0x0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(+((signed int )0x0123456789ABCDEF)));
+    ((void)(+((signed long long int )0x0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )0x0123456789ABCDEFu)));
+    ((void)(+((unsigned long long int )0x0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(-((signed int )0x0123456789ABCDEF)));
+    ((void)(-((signed long long int )0x0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )0x0123456789ABCDEFu)));
+    ((void)(-((unsigned long long int )0x0123456789ABCDEFu)));
+    ((void)((signed char )0X0123456789abcdef));
+    ((void)((signed short int )0X0123456789abcdef));
+    ((void)((signed int )0X0123456789abcdef));
+    ((void)((signed long long int )0X0123456789abcdef));
+    ((void)((signed char )0X0123456789abcdefu));
+    ((void)((unsigned short int )0X0123456789abcdefu));
+    ((void)((signed int )0X0123456789abcdefu));
+    ((void)((unsigned long long int )0X0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(+((signed int )0X0123456789abcdef)));
+    ((void)(+((signed long long int )0X0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(+((signed int )0X0123456789abcdefu)));
+    ((void)(+((unsigned long long int )0X0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(-((signed int )0X0123456789abcdef)));
+    ((void)(-((signed long long int )0X0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(-((signed int )0X0123456789abcdefu)));
+    ((void)(-((unsigned long long int )0X0123456789abcdefu)));
+    ((void)((signed char )0X0123456789ABCDEF));
+    ((void)((signed short int )0X0123456789ABCDEF));
+    ((void)((signed int )0X0123456789ABCDEF));
+    ((void)((signed long long int )0X0123456789ABCDEF));
+    ((void)((signed char )0X0123456789ABCDEFu));
+    ((void)((unsigned short int )0X0123456789ABCDEFu));
+    ((void)((signed int )0X0123456789ABCDEFu));
+    ((void)((unsigned long long int )0X0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(+((signed int )0X0123456789ABCDEF)));
+    ((void)(+((signed long long int )0X0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )0X0123456789ABCDEFu)));
+    ((void)(+((unsigned long long int )0X0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(-((signed int )0X0123456789ABCDEF)));
+    ((void)(-((signed long long int )0X0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )0X0123456789ABCDEFu)));
+    ((void)(-((unsigned long long int )0X0123456789ABCDEFu)));
+    ((void)((float )0123456789.));
+    ((void)((double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)(+((float )0123456789.)));
+    ((void)(+((double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(-((float )0123456789.)));
+    ((void)(-((double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)((float )0123456789.e09));
+    ((void)((double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)(+((float )0123456789.e+09)));
+    ((void)(+((double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(-((float )0123456789.e-09)));
+    ((void)(-((double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)((float ).0123456789e09));
+    ((void)((double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)(+((float ).0123456789E+09)));
+    ((void)(+((double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(-((float ).0123456789E-09)));
+    ((void)(-((double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)((float )0123456789.0123456789));
+    ((void)((double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)(+((float )0123456789.0123456789E09)));
+    ((void)(+((double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(-((float )0123456789.0123456789E+09)));
+    ((void)(-((double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)((float )0123456789.0123456789E-09));
+    ((void)((double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((float )0x0123456789.p09));
+    ((void)((double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)(+((float )0x0123456789.p09)));
+    ((void)(+((double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(-((float )0x0123456789.p09)));
+    ((void)(-((double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)((float )0x0123456789.p+09));
+    ((void)((double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)(+((float )0x0123456789.p-09)));
+    ((void)(+((double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(-((float )0x.0123456789p09)));
+    ((void)(-((double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
     ((void)__f__F_c__1('a'));
     ((void)__f__F_Sc__1(20));
 …
     ((void)L"a" "b" "c");
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/KRfunctions.txt

-              r78315272
+              r3f7e12cb
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
 …
     struct S ___ret__2sS_1;
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
 …
     signed int *__x__FPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
     ((void)(___retval_f10__PFPi_ii__1=__x__FPi_ii__2) /* ?{} */);
     return ((signed int *(*)(signed int __x__i_1, signed int __y__i_1))___retval_f10__PFPi_ii__1);
+    return ___retval_f10__PFPi_ii__1;
+}
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{

src/tests/.expect/64/attributes.txt

-              r78315272
+              r3f7e12cb
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 __attribute__ ((unused)) struct Agn1;
 …
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
     return ((struct Agn2 )___ret__5sAgn2_1);
+    ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
+    return ___ret__5sAgn2_1;
+}
 enum __attribute__ ((unused)) __anonymous1 {
 …
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
 static inline struct Fdl ___operator_assign__F4sFdl_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1);
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1);
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1);
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1);
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1);
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1);
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object1);
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object2, signed int *__f9__Pi_1);
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
 static inline void ___destructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ^?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     ((void)((*___dst__R4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
     return ((struct Fdl )___ret__4sFdl_1);
+    ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__R4sFdl_1)));
+    return ___ret__4sFdl_1;
+}
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1){
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object3){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
 …
     ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, signed int __f1__i_1, signed int __f2__i_1, signed int __f3__i_1, signed int __f4__i_1, signed int __f5__i_1, signed int __f6__i_1, signed int __f7__i_1, signed int __f8__i_1, signed int __anonymous_object4, signed int *__f9__Pi_1){
+    ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__R4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 …
     __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
 __attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,used,unused)) signed int (*__f3__FPA0i_i__1(signed int __anonymous_object5))[];
 __attribute__ ((unused,unused)) signed int (*__f3__FPA0i_i__1(signed int __p__i_1))[]{
     __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object2);
 __attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object3){
     __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object4);
+__attribute__ ((unused,used,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FPFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__PFi_i__1)(signed int __anonymous_object8);
+}
 signed int __vtr__Fi___1(){
 …
 signed int __tpr2__Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **__Foo__PPi_1);
 signed int __tpr3__Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *__Foo__Pi_1);
 signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object5)(__attribute__ ((unused,unused)) signed int __anonymous_object6[((unsigned long int )5)]));
+signed int __tpr4__Fi_PFi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned long int )5)]));
 signed int __tpr5__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr6__Fi_PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__PFi___1)());
 signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object7)(__attribute__ ((unused)) signed int (*__anonymous_object8)(__attribute__ ((unused,unused)) signed int __anonymous_object9)));
+signed int __tpr7__Fi_PFi_PFi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
 signed int __ad__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_ad__i_1;
 …
         struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+        ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__R13s__anonymous4_2)));
+        return ___ret__13s__anonymous4_2;
+    }
     inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, signed int __i__i_2){
 …
+    }
     inline void ___constructor__F_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
+    }
     inline void ___destructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_2){
 …
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_R13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__R13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         enum __anonymous5 ___ret__13e__anonymous5_2;
+        ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+        ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
+        return ___ret__13e__anonymous5_2;
+    }
     ((void)sizeof(enum __anonymous5 ));
+}
 signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object10, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object11);
 signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object13);
 signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
 signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)());
 signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object18)(__attribute__ ((unused)) signed int __anonymous_object19), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(__attribute__ ((unused)) signed int __anonymous_object21));
 signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)());
 signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(__attribute__ ((unused)) signed int __anonymous_object27));
+signed int __apd1__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int __apd2__Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int __apd3__Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int __apd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int __apd6__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_PFi_i_PFi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
 struct Vad {
     __attribute__ ((unused)) signed int __anonymous_object28;
     __attribute__ ((unused,unused)) signed int *__anonymous_object29;
     __attribute__ ((unused,unused)) signed int __anonymous_object30[((unsigned long int )10)];
     __attribute__ ((unused,unused)) signed int (*__anonymous_object31)();
+    __attribute__ ((unused)) signed int __anonymous_object32;
+    __attribute__ ((unused,unused)) signed int *__anonymous_object33;
+    __attribute__ ((unused,unused)) signed int __anonymous_object34[((unsigned long int )10)];
+    __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 …
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object36);
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object37, signed int *__anonymous_object38);
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object39, signed int *__anonymous_object40, signed int __anonymous_object41[((unsigned long int )10)]);
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object42, signed int *__anonymous_object43, signed int __anonymous_object44[((unsigned long int )10)], signed int (*__anonymous_object45)());
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index0 = 0;
+        for (;(_index0<10);((void)(++_index0))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index0)])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
+        signed int _index1 = 0;
+        for (;(_index1<10);((void)(++_index1))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index1)])))=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
 static inline void ___destructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1){
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
+        signed int _index2 = (10-1);
+        for (;(_index2>=0);((void)(--_index2))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index2)])))) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object32) /* ^?{} */);
+}
 static inline struct Vad ___operator_assign__F4sVad_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_1){
     struct Vad ___ret__4sVad_1;
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    return ((struct Vad )___ret__4sVad_1);
+}
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33));
+    {
+        signed int _index3 = 0;
+        for (;(_index3<10);((void)(++_index3))) {
+            ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index3)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index3)]));
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__R4sVad_1)));
+    return ___ret__4sVad_1;
+}
+static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object46){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+    {
+        signed int _index4 = 0;
+        for (;(_index4<10);((void)(++_index4))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index4)])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object47, signed int *__anonymous_object48){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
+        signed int _index5 = 0;
+        for (;(_index5<10);((void)(++_index5))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index5)])))) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object49, signed int *__anonymous_object50, signed int __anonymous_object51[((unsigned long int )10)]){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
+        signed int _index6 = 0;
+        for (;(_index6<10);((void)(++_index6))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index6)])))=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, signed int __anonymous_object52, signed int *__anonymous_object53, signed int __anonymous_object54[((unsigned long int )10)], signed int (*__anonymous_object55)()){
+    ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
+        signed int _index7 = 0;
+        for (;(_index7<10);((void)(++_index7))) {
+            ((void)((*((signed int *)(&(*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index7)])))=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/.expect/64/declarationSpecifier.txt

-              r78315272
+              r3f7e12cb
 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__R13s__anonymous0_1)));
+    return ___ret__13s__anonymous0_1;
+}
 static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+    ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__R13s__anonymous1_1)));
+    return ___ret__13s__anonymous1_1;
+}
 static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+    ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__R13s__anonymous2_1)));
+    return ___ret__13s__anonymous2_1;
+}
 static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+    ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__R13s__anonymous3_1)));
+    return ___ret__13s__anonymous3_1;
+}
 static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+    ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__R13s__anonymous4_1)));
+    return ___ret__13s__anonymous4_1;
+}
 static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+    ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__R13s__anonymous5_1)));
+    return ___ret__13s__anonymous5_1;
+}
 static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+    ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__R13s__anonymous6_1)));
+    return ___ret__13s__anonymous6_1;
+}
 static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1);
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+    ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__R13s__anonymous7_1)));
+    return ___ret__13s__anonymous7_1;
+}
 static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+    ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__R13s__anonymous8_1)));
+    return ___ret__13s__anonymous8_1;
+}
 static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1);
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+    ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__R13s__anonymous9_1)));
+    return ___ret__13s__anonymous9_1;
+}
 static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+    ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__R14s__anonymous10_1)));
+    return ___ret__14s__anonymous10_1;
+}
 static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+    ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__R14s__anonymous11_1)));
+    return ___ret__14s__anonymous11_1;
+}
 static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+    ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__R14s__anonymous12_1)));
+    return ___ret__14s__anonymous12_1;
+}
 static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+    ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__R14s__anonymous13_1)));
+    return ___ret__14s__anonymous13_1;
+}
 static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+    ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__R14s__anonymous14_1)));
+    return ___ret__14s__anonymous14_1;
+}
 static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1);
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1) /* ?{} */);
 …
     struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+    ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__R14s__anonymous15_1)));
+    return ___ret__14s__anonymous15_1;
+}
 static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, signed short int __i__s_1){
 …
 static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+    ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__R14s__anonymous16_1)));
+    return ___ret__14s__anonymous16_1;
+}
 static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+    ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__R14s__anonymous17_1)));
+    return ___ret__14s__anonymous17_1;
+}
 static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+    ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__R14s__anonymous18_1)));
+    return ___ret__14s__anonymous18_1;
+}
 static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+    ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__R14s__anonymous19_1)));
+    return ___ret__14s__anonymous19_1;
+}
 static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+    ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__R14s__anonymous20_1)));
+    return ___ret__14s__anonymous20_1;
+}
 static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+    ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__R14s__anonymous21_1)));
+    return ___ret__14s__anonymous21_1;
+}
 static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+    ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__R14s__anonymous22_1)));
+    return ___ret__14s__anonymous22_1;
+}
 static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, signed int __i__i_1){
 …
 static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1);
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1) /* ?{} */);
 …
     struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+    ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__R14s__anonymous23_1)));
+    return ___ret__14s__anonymous23_1;
+}
 static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, signed int __i__i_1){
 …
     __attribute__ ((unused)) signed int ___retval_main__i_1;
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/extension.txt

-              r78315272
+              r3f7e12cb
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1);
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1);
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__a__i_1) /* ?{} */);
 …
     ((void)((*___dst__R2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__R2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__R2sS_1)));
+    return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
 …
     __extension__ signed int __c__i_1;
 };
+static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1);
+static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1);
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1);
 static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 …
     union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
     return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, signed int __src__i_1){
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(signed int )));
+    ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__R2uU_1)));
+    return ___ret__2uU_1;
+}
+static inline void ___constructor__F_R2uUi_autogen___1(union U *___dst__R2uU_1, signed int __a__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
+}
 __extension__ enum E {
 …
         __extension__ signed int *__z__Pi_2;
     };
+    signed int __i__i_2 = ((signed int )(__extension__ __a__i_1+__extension__ 3));
+    inline void ___constructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
+    }
+    inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */);
+    }
+    inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+        struct S ___ret__2sS_2;
+        ((void)((*___dst__R2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)((*___dst__R2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
+        ((void)((*___dst__R2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
+        ((void)((*___dst__R2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_R2sSiiiPiPiPi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2, signed int *__y__Pi_2, signed int *__z__Pi_2){
+        ((void)((*___dst__R2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__R2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
+    }
+    signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);
     ((void)__extension__ 3);
     ((void)__extension__ __a__i_1);

src/tests/.expect/64/gccExtensions.txt

-              r78315272
+              r3f7e12cb
         ((void)((*___dst__R2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__R2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
         return ((struct S )___ret__2sS_2);
+        ((void)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        return ___ret__2sS_2;
+    }
     inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, signed int __a__i_2){
 …
         ((void)((*___dst__R2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+    }
     signed int __i__i_2 = ((signed int )__extension__ 3);
+    signed int __i__i_2 = __extension__ 3;
     __extension__ signed int __a__i_2;
     __extension__ signed int __b__i_2;
 …
         struct s2 ___ret__3ss2_2;
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
         return ((struct s2 )___ret__3ss2_2);
+        ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__R3ss2_2)));
+        return ___ret__3ss2_2;
+    }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
 …
         struct s3 ___ret__3ss3_2;
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
         return ((struct s3 )___ret__3ss3_2);
+        ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__R3ss3_2)));
+        return ___ret__3ss3_2;
+    }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
 …
         struct s4 ___ret__3ss4_2;
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
         return ((struct s4 )___ret__3ss4_2);
+        ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__R3ss4_2)));
+        return ___ret__3ss4_2;
+    }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
 …
     signed int __m3__A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
     ((void)(___retval_main__i_1=((signed int )0)) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi_iPPCc__1(argc, argv); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}

src/tests/.expect/64/literals.txt

-              r78315272
+              r3f7e12cb
 __attribute__ ((__nothrow__,__leaf__,__noreturn__)) extern void exit(signed int __status);
 extern signed int printf(const char *__restrict __format, ...);
 void __for_each__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
 void __for_each_reverse__A2_0_0_0____operator_assign__PFt0_Rt0t0____constructor__PF_Rt0____constructor__PF_Rt0t0____destructor__PF_Rt0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_preincr__PFt0_Rt0____operator_predecr__PFt0_Rt0____operator_equal__PFi_t0t0____operator_notequal__PFi_t0t0____operator_deref__PFRt1_t0__F_t0t0PF_t1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
+void __for_each__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object0)(), void *__anonymous_object1), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object2)(), void *__anonymous_object3), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object4)(), void *__anonymous_object5, void *__anonymous_object6), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object7)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object8), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object9)(), void *__anonymous_object10, void *__anonymous_object11), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object12)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object13, void *__anonymous_object14), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object15)(), void *__anonymous_object16, void *__anonymous_object17), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object18)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object19, void *__anonymous_object20), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object40));
+void __for_each_reverse__A0_2_0_0____operator_assign__PFd0_Rd0d0____constructor__PF_Rd0____constructor__PF_Rd0d0____destructor__PF_Rd0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_preincr__PFd0_Rd0____operator_predecr__PFd0_Rd0____operator_equal__PFi_d0d0____operator_notequal__PFi_d0d0____operator_deref__PFRd1_d0__F_d0d0PF_d1___1(__attribute__ ((unused)) void (*_adapterF_9telt_type__P)(void (*__anonymous_object41)(), void *__anonymous_object42), __attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object43)(), void *__anonymous_object44), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object45)(), void *__anonymous_object46, void *__anonymous_object47), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object48)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object49), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object50)(), void *__anonymous_object51, void *__anonymous_object52), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object53)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object54, void *__anonymous_object55), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object56)(), void *__anonymous_object57, void *__anonymous_object58), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object59)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object60, void *__anonymous_object61), __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__PF_9telt_type__1)(void *__anonymous_object81));
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object103), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, char __anonymous_object109);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object131), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, signed char __anonymous_object137);
 …
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCi__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object642), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object643), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object644, _Bool __anonymous_object645), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object646), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object647, const char *__anonymous_object648), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object649), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object650, _Bool __anonymous_object651), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object652), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object653), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object654), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object655), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object657, const char *__anonymous_object658), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object659), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object660, const char *__anonymous_object661), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object664, const char *__anonymous_object665, unsigned long int __anonymous_object666), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object667, const char *__fmt__PCc_1, ...), void *__anonymous_object668, const signed int *__anonymous_object669);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object670), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object671), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object672, _Bool __anonymous_object673), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object675, const char *__anonymous_object676), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object677), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object678, _Bool __anonymous_object679), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object680), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object681), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object684), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object685, const char *__anonymous_object686), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object687), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object688, const char *__anonymous_object689), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object692, const char *__anonymous_object693, unsigned long int __anonymous_object694), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object695, const char *__fmt__PCc_1, ...), void *__anonymous_object696, const void *__anonymous_object697);
 void *___operator_bitor__A1_1_0_1____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_bitor__PFPd0_Pd0t1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_bitor__PFPd0_Pd0tVARGS2__FPd0_Pd0t1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object698)(), void *__anonymous_object699, void *__anonymous_object700), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object701)(), void *__anonymous_object702, void *__anonymous_object703), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object704)(), void *__anonymous_object705, void *__anonymous_object706), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object707)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object708, void *__anonymous_object709), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object710, void *__anonymous_object711), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object713, void *__anonymous_object714), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object715), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype2tT__1)(void *__anonymous_object716, void *__anonymous_object717), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object720, _Bool __anonymous_object721), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object722), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object723, const char *__anonymous_object724), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object726, _Bool __anonymous_object727), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object728), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object733, const char *__anonymous_object734), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object736, const char *__anonymous_object737), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object740, const char *__anonymous_object741, unsigned long int __anonymous_object742), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object743, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype7tParams__1)(void *__anonymous_object744, void *__anonymous_object745), void *__os__P7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
+void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFPd0_Pd0d1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_bitor__PFPd0_Pd0tVARGS2__FPd0_Pd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object698)(), void *__anonymous_object699, void *__anonymous_object700), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object701)(), void *__anonymous_object702, void *__anonymous_object703), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object704)(), void *__anonymous_object705, void *__anonymous_object706), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object707)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object708, void *__anonymous_object709), __attribute__ ((unused)) unsigned long int _sizeof_2tT, __attribute__ ((unused)) unsigned long int _alignof_2tT, __attribute__ ((unused)) unsigned long int _sizeof_7tParams, __attribute__ ((unused)) unsigned long int _alignof_7tParams, __attribute__ ((unused)) void *(*___operator_assign__PF2tT_R2tT2tT__1)(void *__anonymous_object710, void *__anonymous_object711), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object712), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object713, void *__anonymous_object714), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object715), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype2tT__1)(void *__anonymous_object716, void *__anonymous_object717), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object718), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object720, _Bool __anonymous_object721), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object722), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object723, const char *__anonymous_object724), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object725), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object726, _Bool __anonymous_object727), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object728), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object733, const char *__anonymous_object734), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object735), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object736, const char *__anonymous_object737), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object738), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object740, const char *__anonymous_object741, unsigned long int __anonymous_object742), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object743, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype7tParams__1)(void *__anonymous_object744, void *__anonymous_object745), void *__os__P7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772, void *(*__anonymous_object773)(void *__anonymous_object774));
 void *__endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object775), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object776), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object777, _Bool __anonymous_object778), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object779), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object780, const char *__anonymous_object781), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object782), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object783, _Bool __anonymous_object784), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object788), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object789), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object790, const char *__anonymous_object791), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object792), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object793, const char *__anonymous_object794), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object795), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object796), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object797, const char *__anonymous_object798, unsigned long int __anonymous_object799), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object800, const char *__fmt__PCc_1, ...), void *__anonymous_object801);
 …
 void *__sepDisable__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object910), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object911), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object912, _Bool __anonymous_object913), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object914), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object915, const char *__anonymous_object916), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object917), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object918, _Bool __anonymous_object919), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object920), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object921), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object922), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object923), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object924), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object925, const char *__anonymous_object926), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object927), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object928, const char *__anonymous_object929), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object930), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object931), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object932, const char *__anonymous_object933, unsigned long int __anonymous_object934), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object935, const char *__fmt__PCc_1, ...), void *__anonymous_object936);
 void *__sepEnable__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object937), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object939, _Bool __anonymous_object940), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object941), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object942, const char *__anonymous_object943), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object944), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object945, _Bool __anonymous_object946), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object947), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object952, const char *__anonymous_object953), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object954), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object955, const char *__anonymous_object956), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object957), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object959, const char *__anonymous_object960, unsigned long int __anonymous_object961), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object962, const char *__fmt__PCc_1, ...), void *__anonymous_object963);
 void __write__A2_1_0_0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_bitor__PFPd0_Pd0t1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFt2_Rt2t2____constructor__PF_Rt2____constructor__PF_Rt2t2____destructor__PF_Rt2____operator_preincr__PFt2_Rt2____operator_predecr__PFt2_Rt2____operator_equal__PFi_t2t2____operator_notequal__PFi_t2t2____operator_deref__PFRt1_t2__F_t2t2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object964)(), void *__anonymous_object965), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object966)(), void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object969)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object970), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object971)(), void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object974)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object975, void *__anonymous_object976), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object977)(), void *__anonymous_object978, void *__anonymous_object979), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object980)(), void *__anonymous_object981, void *__anonymous_object982), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object983)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object984, void *__anonymous_object985), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object986, void *__anonymous_object987), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object988), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object989, void *__anonymous_object990), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object991), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object992, void *__anonymous_object993), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object994), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object995), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object996, _Bool __anonymous_object997), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object998), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object999, const char *__anonymous_object1000), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1002, _Bool __anonymous_object1003), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1004), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1005), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1009, const char *__anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1015), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1016, const char *__anonymous_object1017, unsigned long int __anonymous_object1018), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1019, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1023, void *__anonymous_object1024), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1025), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1026), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1028, void *__anonymous_object1029), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1030, void *__anonymous_object1031), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1032), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
 void __write_reverse__A2_1_0_0____operator_assign__PFt1_Rt1t1____constructor__PF_Rt1____constructor__PF_Rt1t1____destructor__PF_Rt1____operator_bitor__PFPd0_Pd0t1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFt2_Rt2t2____constructor__PF_Rt2____constructor__PF_Rt2t2____destructor__PF_Rt2____operator_preincr__PFt2_Rt2____operator_predecr__PFt2_Rt2____operator_equal__PFi_t2t2____operator_notequal__PFi_t2t2____operator_deref__PFRt1_t2__F_t2t2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1033)(), void *__anonymous_object1034), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1035)(), void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1038)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1039), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1040)(), void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1043)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1044, void *__anonymous_object1045), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1046)(), void *__anonymous_object1047, void *__anonymous_object1048), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1049)(), void *__anonymous_object1050, void *__anonymous_object1051), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1052)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1053, void *__anonymous_object1054), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1055, void *__anonymous_object1056), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1060), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object1061, void *__anonymous_object1062), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object1063), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object1064), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object1065, _Bool __anonymous_object1066), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object1068, const char *__anonymous_object1069), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1070), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1071, _Bool __anonymous_object1072), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1073), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1074), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1075), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1076), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1078, const char *__anonymous_object1079), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1080), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1081, const char *__anonymous_object1082), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1083), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1084), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1085, const char *__anonymous_object1086, unsigned long int __anonymous_object1087), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1088, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1092, void *__anonymous_object1093), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1094), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1095), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1097, void *__anonymous_object1098), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1099, void *__anonymous_object1100), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1101), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
+void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFPd0_Pd0d1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object964)(), void *__anonymous_object965), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object966)(), void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object969)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object970), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object971)(), void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object974)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object975, void *__anonymous_object976), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object977)(), void *__anonymous_object978, void *__anonymous_object979), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object980)(), void *__anonymous_object981, void *__anonymous_object982), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object983)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object984, void *__anonymous_object985), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object986, void *__anonymous_object987), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object988), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object989, void *__anonymous_object990), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object991), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object992, void *__anonymous_object993), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object994), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object995), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object996, _Bool __anonymous_object997), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object998), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object999, const char *__anonymous_object1000), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1002, _Bool __anonymous_object1003), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1004), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1005), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1009, const char *__anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1015), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1016, const char *__anonymous_object1017, unsigned long int __anonymous_object1018), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1019, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1020, void *__anonymous_object1021), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1022), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1023, void *__anonymous_object1024), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1025), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1026), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1028, void *__anonymous_object1029), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1030, void *__anonymous_object1031), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1032), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
+void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFPd0_Pd0d1___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc____operator_assign__PFd2_Rd2d2____constructor__PF_Rd2____constructor__PF_Rd2d2____destructor__PF_Rd2____operator_preincr__PFd2_Rd2____operator_predecr__PFd2_Rd2____operator_equal__PFi_d2d2____operator_notequal__PFi_d2d2____operator_deref__PFRd1_d2__F_d2d2Pd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object1033)(), void *__anonymous_object1034), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object1035)(), void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object1038)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object1039), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object1040)(), void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object1043)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object1044, void *__anonymous_object1045), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object1046)(), void *__anonymous_object1047, void *__anonymous_object1048), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object1049)(), void *__anonymous_object1050, void *__anonymous_object1051), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object1052)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object1053, void *__anonymous_object1054), __attribute__ ((unused)) unsigned long int _sizeof_9telt_type, __attribute__ ((unused)) unsigned long int _alignof_9telt_type, __attribute__ ((unused)) unsigned long int _sizeof_14titerator_type, __attribute__ ((unused)) unsigned long int _alignof_14titerator_type, __attribute__ ((unused)) void *(*___operator_assign__PF9telt_type_R9telt_type9telt_type__1)(void *__anonymous_object1055, void *__anonymous_object1056), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1058, void *__anonymous_object1059), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1060), __attribute__ ((unused)) void *(*___operator_bitor__PFP7tostype_P7tostype9telt_type__1)(void *__anonymous_object1061, void *__anonymous_object1062), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_P7tostype__1)(void *__anonymous_object1063), __attribute__ ((unused)) void (*__sepReset__PF_P7tostype__1)(void *__anonymous_object1064), __attribute__ ((unused)) void (*__sepReset__PF_P7tostypeb__1)(void *__anonymous_object1065, _Bool __anonymous_object1066), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_P7tostype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__sepSetCur__PF_P7tostypePCc__1)(void *__anonymous_object1068, const char *__anonymous_object1069), __attribute__ ((unused)) _Bool (*__getNL__PFb_P7tostype__1)(void *__anonymous_object1070), __attribute__ ((unused)) void (*__setNL__PF_P7tostypeb__1)(void *__anonymous_object1071, _Bool __anonymous_object1072), __attribute__ ((unused)) void (*__sepOn__PF_P7tostype__1)(void *__anonymous_object1073), __attribute__ ((unused)) void (*__sepOff__PF_P7tostype__1)(void *__anonymous_object1074), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_P7tostype__1)(void *__anonymous_object1075), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_P7tostype__1)(void *__anonymous_object1076), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_P7tostype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__sepSet__PF_P7tostypePCc__1)(void *__anonymous_object1078, const char *__anonymous_object1079), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_P7tostype__1)(void *__anonymous_object1080), __attribute__ ((unused)) void (*__sepSetTuple__PF_P7tostypePCc__1)(void *__anonymous_object1081, const char *__anonymous_object1082), __attribute__ ((unused)) signed int (*__fail__PFi_P7tostype__1)(void *__anonymous_object1083), __attribute__ ((unused)) signed int (*__flush__PFi_P7tostype__1)(void *__anonymous_object1084), __attribute__ ((unused)) void (*__open__PF_P7tostypePCcPCc__1)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tostype__1)(void *__os__P7tostype_1), __attribute__ ((unused)) void *(*__write__PFP7tostype_P7tostypePCcUl__1)(void *__anonymous_object1085, const char *__anonymous_object1086, unsigned long int __anonymous_object1087), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tostypePCc__1)(void *__anonymous_object1088, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1089, void *__anonymous_object1090), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1091), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1092, void *__anonymous_object1093), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1094), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1095), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1097, void *__anonymous_object1098), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1099, void *__anonymous_object1100), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1101), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__P7tostype_1);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1102), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1103), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1104, char *__anonymous_object1105, unsigned long int __anonymous_object1106), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1107, char __anonymous_object1108), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1109, const char *__fmt__PCc_1, ...), void *__anonymous_object1110, char *__anonymous_object1111);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1112), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1113), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1114, char *__anonymous_object1115, unsigned long int __anonymous_object1116), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1117, char __anonymous_object1118), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1119, const char *__fmt__PCc_1, ...), void *__anonymous_object1120, signed char *__anonymous_object1121);
 …
 static inline void ___destructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1);
 static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1);
 static inline void ___constructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1) /* ?{} */);
 …
     struct _Istream_cstrUC ___ret__16s_Istream_cstrUC_1;
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
     ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), ___src__16s_Istream_cstrUC_1));
     return ((struct _Istream_cstrUC )___ret__16s_Istream_cstrUC_1);
+    ((void)___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), (*___dst__R16s_Istream_cstrUC_1)));
+    return ___ret__16s_Istream_cstrUC_1;
+}
 static inline void ___constructor__F_R16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, char *__s__Pc_1){
 …
 static inline void ___destructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1);
 static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1);
+static inline void ___constructor__F_R15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1);
 static inline void ___constructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1){
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1) /* ?{} */);
 …
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1));
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
     ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), ___src__15s_Istream_cstrC_1));
     return ((struct _Istream_cstrC )___ret__15s_Istream_cstrC_1);
+    ((void)___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), (*___dst__R15s_Istream_cstrC_1)));
+    return ___ret__15s_Istream_cstrC_1;
+}
 static inline void ___constructor__F_R15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, char *__s__Pc_1){
 …
 void *___operator_bitor__A0_1_0_0___fail__PFi_Pd0___eof__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___read__PFPd0_Pd0PcUl___ungetc__PFPd0_Pd0c___fmt__PFi_Pd0PCc__FPd0_Pd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_P7tistype__1)(void *__anonymous_object1284), __attribute__ ((unused)) signed int (*__eof__PFi_P7tistype__1)(void *__anonymous_object1285), __attribute__ ((unused)) void (*__open__PF_P7tistypePCcPCc__1)(void *__is__P7tistype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_P7tistype__1)(void *__is__P7tistype_1), __attribute__ ((unused)) void *(*__read__PFP7tistype_P7tistypePcUl__1)(void *__anonymous_object1286, char *__anonymous_object1287, unsigned long int __anonymous_object1288), __attribute__ ((unused)) void *(*__ungetc__PFP7tistype_P7tistypec__1)(void *__anonymous_object1289, char __anonymous_object1290), __attribute__ ((unused)) signed int (*__fmt__PFi_P7tistypePCc__1)(void *__anonymous_object1291, const char *__fmt__PCc_1, ...), void *__anonymous_object1292, struct _Istream_cstrC __anonymous_object1293);
 enum __anonymous0 {
     __sepSize__C13e__anonymous0_1 = ((signed int )16),
+    __sepSize__C13e__anonymous0_1 = 16,
 };
 struct ofstream {
 …
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
 static inline struct ofstream ___operator_assign__F9sofstream_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1);
+static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]);
+static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]);
 static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
     ((void)((*___dst__R9sofstream_1).__file__Pv_1) /* ?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index0 = ((signed int )0);
+        signed int _index0 = 0;
         for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index0)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index1 = ((signed int )0);
+    {
+        signed int _index1 = 0;
         for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index1)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index2 = ((signed int )0);
+        signed int _index2 = 0;
         for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index2)])))=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
 …
+    }
+    {
+        signed int _index3 = ((signed int )0);
+    {
+        signed int _index3 = 0;
         for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index3)])))=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index3)]) /* ?{} */);
 …
+    }
+}
 static inline void ___destructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1){
+    {
         signed int _index4 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+        signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index4>=0);((void)(--_index4))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)])))) /* ^?{} */);
 …
+    }
+    {
+        signed int _index5 = ((signed int )(((signed int )__sepSize__C13e__anonymous0_1)-1));
+    {
+        signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index5>=0);((void)(--_index5))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index5)])))) /* ^?{} */);
 …
+    }
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ^?{} */);
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    {
         signed int _index6 = ((signed int )0);
+        signed int _index6 = 0;
         for (;(_index6<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index6))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index6)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index6)]));
 …
+    {
         signed int _index7 = ((signed int )0);
+        signed int _index7 = 0;
         for (;(_index7<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index7))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index7)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index7)]));
 …
+    }
     ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), ___src__9sofstream_1));
     return ((struct ofstream )___ret__9sofstream_1);
+    ((void)___constructor__F_R9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), (*___dst__R9sofstream_1)));
+    return ___ret__9sofstream_1;
+}
 static inline void ___constructor__F_R9sofstreamPv_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index8 = ((signed int )0);
+        signed int _index8 = 0;
         for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index8)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index9 = ((signed int )0);
+    {
+        signed int _index9 = 0;
         for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index9)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index10 = ((signed int )0);
+        signed int _index10 = 0;
         for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index10)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index11 = ((signed int )0);
+    {
+        signed int _index11 = 0;
         for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index11)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index12 = ((signed int )0);
+        signed int _index12 = 0;
         for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index12)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index13 = ((signed int )0);
+    {
+        signed int _index13 = 0;
         for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index13)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbb_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index14 = ((signed int )0);
+        signed int _index14 = 0;
         for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index14)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index15 = ((signed int )0);
+    {
+        signed int _index15 = 0;
         for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index15)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index16 = ((signed int )0);
+        signed int _index16 = 0;
         for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index16)])))) /* ?{} */);
 …
+    }
+    {
+        signed int _index17 = ((signed int )0);
+    {
+        signed int _index17 = 0;
         for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index17)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index18 = ((signed int )0);
+        signed int _index18 = 0;
         for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)])))=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
 …
+    }
+    {
+        signed int _index19 = ((signed int )0);
+    {
+        signed int _index19 = 0;
         for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)])))) /* ?{} */);
 …
+    }
+}
 static inline void ___constructor__F_R9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__R9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1, char __separator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)], char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)]){
 …
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index20 = ((signed int )0);
+        signed int _index20 = 0;
         for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)])))=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
 …
+    }
+    {
+        signed int _index21 = ((signed int )0);
+    {
+        signed int _index21 = 0;
         for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
             ((void)((*((char *)(&(*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)])))=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
 …
+    }
+}
 _Bool __sepPrt__Fb_P9sofstream__1(struct ofstream *__anonymous_object1294);
 …
 static inline void ___destructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1);
 static inline struct ifstream ___operator_assign__F9sifstream_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1);
 static inline void ___constructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1) /* ?{} */);
 …
     struct ifstream ___ret__9sifstream_1;
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
     ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), ___src__9sifstream_1));
     return ((struct ifstream )___ret__9sifstream_1);
+    ((void)___constructor__F_R9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), (*___dst__R9sifstream_1)));
+    return ___ret__9sifstream_1;
+}
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
 …
     struct ofstream *_tmp_cp_ret2;
     __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1322))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1323))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1324, _Bool __anonymous_object1325))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1326))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1327, const char *__anonymous_object1328))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1329))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1330, _Bool __anonymous_object1331))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1332))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1333))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1335))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1336))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1337, const char *__anonymous_object1338))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1339))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1340, const char *__anonymous_object1341))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1342))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1343))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1344, const char *__anonymous_object1345, unsigned long int __anonymous_object1346))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1347, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1348))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1349))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1350, _Bool __anonymous_object1351))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1352))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1353, const char *__anonymous_object1354))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1355))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1356, _Bool __anonymous_object1357))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1358))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1359))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1362))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1363, const char *__anonymous_object1364))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1365))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1366, const char *__anonymous_object1367))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1368))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1369))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1370, const char *__anonymous_object1371, unsigned long int __anonymous_object1372))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1373, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret1=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(((_Bool (*)(void *__anonymous_object1374))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1375))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1376, _Bool __anonymous_object1377))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1378))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1379, const char *__anonymous_object1380))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1381))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1382, _Bool __anonymous_object1383))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1384))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1385))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1388))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1389, const char *__anonymous_object1390))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1391))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1392, const char *__anonymous_object1393))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1394))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1395))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1396, const char *__anonymous_object1397, unsigned long int __anonymous_object1398))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1399, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret0=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1400))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1401))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1402, _Bool __anonymous_object1403))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1404))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1405, const char *__anonymous_object1406))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1407))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1408, _Bool __anonymous_object1409))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1410))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1411))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1414))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1415, const char *__anonymous_object1416))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1417))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1418, const char *__anonymous_object1419))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1420))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1421))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1422, const char *__anonymous_object1423, unsigned long int __anonymous_object1424))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1425, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "char "))) , _tmp_cp_ret0), __v__c_1))) , _tmp_cp_ret1), ((void *(*)(void *__anonymous_object1426))(&_thunk0))))) , _tmp_cp_ret2));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1322))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1323))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1324, _Bool __anonymous_object1325))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1326))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1327, const char *__anonymous_object1328))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1329))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1330, _Bool __anonymous_object1331))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1332))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1333))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1334))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1335))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1336))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1337, const char *__anonymous_object1338))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1339))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1340, const char *__anonymous_object1341))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1342))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1343))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1344, const char *__anonymous_object1345, unsigned long int __anonymous_object1346))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1347, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1348))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1349))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1350, _Bool __anonymous_object1351))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1352))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1353, const char *__anonymous_object1354))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1355))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1356, _Bool __anonymous_object1357))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1358))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1359))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1360))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1362))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1363, const char *__anonymous_object1364))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1365))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1366, const char *__anonymous_object1367))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1368))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1369))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1370, const char *__anonymous_object1371, unsigned long int __anonymous_object1372))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1373, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret1=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0c__1(((_Bool (*)(void *__anonymous_object1374))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1375))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1376, _Bool __anonymous_object1377))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1378))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1379, const char *__anonymous_object1380))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1381))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1382, _Bool __anonymous_object1383))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1384))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1385))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1386))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1388))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1389, const char *__anonymous_object1390))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1391))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1392, const char *__anonymous_object1393))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1394))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1395))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1396, const char *__anonymous_object1397, unsigned long int __anonymous_object1398))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1399, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret0=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1400))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1401))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1402, _Bool __anonymous_object1403))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1404))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1405, const char *__anonymous_object1406))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1407))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1408, _Bool __anonymous_object1409))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1410))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1411))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1412))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1414))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1415, const char *__anonymous_object1416))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1417))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1418, const char *__anonymous_object1419))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1420))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1421))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1422, const char *__anonymous_object1423, unsigned long int __anonymous_object1424))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1425, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "char "))) , _tmp_cp_ret0)), __v__c_1))) , _tmp_cp_ret1)), ((void *(*)(void *__anonymous_object1426))(&_thunk0))))) , _tmp_cp_ret2));
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     ((void)(_tmp_cp_ret1) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret5;
     __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1453))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1454))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1455, _Bool __anonymous_object1456))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1457))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1458, const char *__anonymous_object1459))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1460))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1463))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1464))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1467))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1468, const char *__anonymous_object1469))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1470))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1471, const char *__anonymous_object1472))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1473))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1474))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1475, const char *__anonymous_object1476, unsigned long int __anonymous_object1477))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1478, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(((_Bool (*)(void *__anonymous_object1479))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1480))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1481, _Bool __anonymous_object1482))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1483))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1484, const char *__anonymous_object1485))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1486))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1489))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1490))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1493))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1494, const char *__anonymous_object1495))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1496))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1497, const char *__anonymous_object1498))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1499))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1500))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1501, const char *__anonymous_object1502, unsigned long int __anonymous_object1503))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1504, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1505))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1506))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1507, _Bool __anonymous_object1508))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1509))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1510, const char *__anonymous_object1511))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1512))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1515))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1516))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1519))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1520, const char *__anonymous_object1521))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1522))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1523, const char *__anonymous_object1524))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1525))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1526))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1527, const char *__anonymous_object1528, unsigned long int __anonymous_object1529))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1530, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed char "))) , _tmp_cp_ret3), __v__Sc_1))) , _tmp_cp_ret4), ((void *(*)(void *__anonymous_object1531))(&_thunk1))))) , _tmp_cp_ret5));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1453))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1454))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1455, _Bool __anonymous_object1456))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1457))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1458, const char *__anonymous_object1459))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1460))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1461, _Bool __anonymous_object1462))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1463))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1464))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1465))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1467))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1468, const char *__anonymous_object1469))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1470))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1471, const char *__anonymous_object1472))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1473))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1474))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1475, const char *__anonymous_object1476, unsigned long int __anonymous_object1477))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1478, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Sc__1(((_Bool (*)(void *__anonymous_object1479))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1480))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1481, _Bool __anonymous_object1482))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1483))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1484, const char *__anonymous_object1485))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1486))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1487, _Bool __anonymous_object1488))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1489))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1490))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1491))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1493))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1494, const char *__anonymous_object1495))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1496))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1497, const char *__anonymous_object1498))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1499))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1500))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1501, const char *__anonymous_object1502, unsigned long int __anonymous_object1503))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1504, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1505))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1506))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1507, _Bool __anonymous_object1508))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1509))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1510, const char *__anonymous_object1511))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1512))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1513, _Bool __anonymous_object1514))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1515))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1516))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1517))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1519))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1520, const char *__anonymous_object1521))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1522))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1523, const char *__anonymous_object1524))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1525))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1526))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1527, const char *__anonymous_object1528, unsigned long int __anonymous_object1529))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1530, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "signed char "))) , _tmp_cp_ret3)), __v__Sc_1))) , _tmp_cp_ret4)), ((void *(*)(void *__anonymous_object1531))(&_thunk1))))) , _tmp_cp_ret5));
     ((void)(_tmp_cp_ret3) /* ^?{} */);
     ((void)(_tmp_cp_ret4) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret8;
     __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1558))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1559))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1560, _Bool __anonymous_object1561))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1562))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1563, const char *__anonymous_object1564))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1565))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1568))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1569))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1572))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1573, const char *__anonymous_object1574))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1575))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1576, const char *__anonymous_object1577))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1578))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1579))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1580, const char *__anonymous_object1581, unsigned long int __anonymous_object1582))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1583, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Uc__1(((_Bool (*)(void *__anonymous_object1584))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1585))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1586, _Bool __anonymous_object1587))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1588))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1589, const char *__anonymous_object1590))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1591))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1594))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1595))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1598))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1599, const char *__anonymous_object1600))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1601))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1602, const char *__anonymous_object1603))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1604))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1605))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1606, const char *__anonymous_object1607, unsigned long int __anonymous_object1608))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1609, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1610))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1611))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1612, _Bool __anonymous_object1613))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1614))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1615, const char *__anonymous_object1616))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1617))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1620))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1621))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1624))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1625, const char *__anonymous_object1626))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1627))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1628, const char *__anonymous_object1629))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1630))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1631))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1632, const char *__anonymous_object1633, unsigned long int __anonymous_object1634))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1635, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned char "))) , _tmp_cp_ret6), __v__Uc_1))) , _tmp_cp_ret7), ((void *(*)(void *__anonymous_object1636))(&_thunk2))))) , _tmp_cp_ret8));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1558))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1559))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1560, _Bool __anonymous_object1561))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1562))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1563, const char *__anonymous_object1564))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1565))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1566, _Bool __anonymous_object1567))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1568))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1569))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1570))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1572))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1573, const char *__anonymous_object1574))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1575))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1576, const char *__anonymous_object1577))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1578))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1579))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1580, const char *__anonymous_object1581, unsigned long int __anonymous_object1582))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1583, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Uc__1(((_Bool (*)(void *__anonymous_object1584))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1585))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1586, _Bool __anonymous_object1587))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1588))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1589, const char *__anonymous_object1590))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1591))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1592, _Bool __anonymous_object1593))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1594))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1595))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1596))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1598))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1599, const char *__anonymous_object1600))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1601))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1602, const char *__anonymous_object1603))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1604))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1605))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1606, const char *__anonymous_object1607, unsigned long int __anonymous_object1608))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1609, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1610))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1611))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1612, _Bool __anonymous_object1613))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1614))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1615, const char *__anonymous_object1616))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1617))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1618, _Bool __anonymous_object1619))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1620))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1621))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1622))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1624))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1625, const char *__anonymous_object1626))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1627))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1628, const char *__anonymous_object1629))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1630))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1631))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1632, const char *__anonymous_object1633, unsigned long int __anonymous_object1634))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1635, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "unsigned char "))) , _tmp_cp_ret6)), __v__Uc_1))) , _tmp_cp_ret7)), ((void *(*)(void *__anonymous_object1636))(&_thunk2))))) , _tmp_cp_ret8));
     ((void)(_tmp_cp_ret6) /* ^?{} */);
     ((void)(_tmp_cp_ret7) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret11;
     __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1663))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1664))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1665, _Bool __anonymous_object1666))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1667))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1668, const char *__anonymous_object1669))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1670))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1673))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1674))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1677))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1678, const char *__anonymous_object1679))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1680))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1681, const char *__anonymous_object1682))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1683))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1684))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1685, const char *__anonymous_object1686, unsigned long int __anonymous_object1687))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1688, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0s__1(((_Bool (*)(void *__anonymous_object1689))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1690))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1691, _Bool __anonymous_object1692))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1693))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1694, const char *__anonymous_object1695))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1696))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1699))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1700))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1703))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1704, const char *__anonymous_object1705))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1706))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1707, const char *__anonymous_object1708))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1709))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1710))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1711, const char *__anonymous_object1712, unsigned long int __anonymous_object1713))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1714, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1715))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1716))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1717, _Bool __anonymous_object1718))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1719))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1720, const char *__anonymous_object1721))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1722))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1725))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1726))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1729))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1730, const char *__anonymous_object1731))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1732))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1733, const char *__anonymous_object1734))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1735))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1736))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1737, const char *__anonymous_object1738, unsigned long int __anonymous_object1739))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1740, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "signed short int"))) , _tmp_cp_ret9), __v__s_1))) , _tmp_cp_ret10), ((void *(*)(void *__anonymous_object1741))(&_thunk3))))) , _tmp_cp_ret11));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1663))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1664))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1665, _Bool __anonymous_object1666))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1667))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1668, const char *__anonymous_object1669))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1670))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1671, _Bool __anonymous_object1672))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1673))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1674))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1675))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1677))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1678, const char *__anonymous_object1679))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1680))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1681, const char *__anonymous_object1682))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1683))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1684))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1685, const char *__anonymous_object1686, unsigned long int __anonymous_object1687))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1688, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0s__1(((_Bool (*)(void *__anonymous_object1689))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1690))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1691, _Bool __anonymous_object1692))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1693))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1694, const char *__anonymous_object1695))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1696))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1697, _Bool __anonymous_object1698))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1699))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1700))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1701))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1703))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1704, const char *__anonymous_object1705))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1706))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1707, const char *__anonymous_object1708))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1709))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1710))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1711, const char *__anonymous_object1712, unsigned long int __anonymous_object1713))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1714, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1715))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1716))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1717, _Bool __anonymous_object1718))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1719))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1720, const char *__anonymous_object1721))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1722))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1723, _Bool __anonymous_object1724))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1725))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1726))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1727))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1729))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1730, const char *__anonymous_object1731))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1732))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1733, const char *__anonymous_object1734))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1735))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1736))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1737, const char *__anonymous_object1738, unsigned long int __anonymous_object1739))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1740, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "signed short int"))) , _tmp_cp_ret9)), __v__s_1))) , _tmp_cp_ret10)), ((void *(*)(void *__anonymous_object1741))(&_thunk3))))) , _tmp_cp_ret11));
     ((void)(_tmp_cp_ret9) /* ^?{} */);
     ((void)(_tmp_cp_ret10) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret14;
     __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1768))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1769))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1770, _Bool __anonymous_object1771))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1772))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1773, const char *__anonymous_object1774))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1775))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1778))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1779))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1782))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1783, const char *__anonymous_object1784))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1785))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1786, const char *__anonymous_object1787))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1788))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1789))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1790, const char *__anonymous_object1791, unsigned long int __anonymous_object1792))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1793, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Us__1(((_Bool (*)(void *__anonymous_object1794))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1795))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1796, _Bool __anonymous_object1797))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1798))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1799, const char *__anonymous_object1800))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1801))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1804))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1805))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1808))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1809, const char *__anonymous_object1810))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1811))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1812, const char *__anonymous_object1813))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1814))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1815))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1816, const char *__anonymous_object1817, unsigned long int __anonymous_object1818))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1819, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1820))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1821))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1822, _Bool __anonymous_object1823))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1824))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1825, const char *__anonymous_object1826))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1827))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1830))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1831))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1834))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1835, const char *__anonymous_object1836))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1837))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1838, const char *__anonymous_object1839))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1840))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1841))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1842, const char *__anonymous_object1843, unsigned long int __anonymous_object1844))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1845, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "unsigned short int"))) , _tmp_cp_ret12), __v__Us_1))) , _tmp_cp_ret13), ((void *(*)(void *__anonymous_object1846))(&_thunk4))))) , _tmp_cp_ret14));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1768))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1769))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1770, _Bool __anonymous_object1771))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1772))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1773, const char *__anonymous_object1774))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1775))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1776, _Bool __anonymous_object1777))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1778))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1779))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1780))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1782))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1783, const char *__anonymous_object1784))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1785))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1786, const char *__anonymous_object1787))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1788))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1789))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1790, const char *__anonymous_object1791, unsigned long int __anonymous_object1792))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1793, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Us__1(((_Bool (*)(void *__anonymous_object1794))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1795))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1796, _Bool __anonymous_object1797))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1798))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1799, const char *__anonymous_object1800))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1801))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1802, _Bool __anonymous_object1803))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1804))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1805))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1806))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1808))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1809, const char *__anonymous_object1810))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1811))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1812, const char *__anonymous_object1813))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1814))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1815))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1816, const char *__anonymous_object1817, unsigned long int __anonymous_object1818))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1819, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1820))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1821))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1822, _Bool __anonymous_object1823))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1824))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1825, const char *__anonymous_object1826))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1827))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1828, _Bool __anonymous_object1829))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1830))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1831))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1832))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1834))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1835, const char *__anonymous_object1836))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1837))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1838, const char *__anonymous_object1839))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1840))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1841))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1842, const char *__anonymous_object1843, unsigned long int __anonymous_object1844))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1845, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "unsigned short int"))) , _tmp_cp_ret12)), __v__Us_1))) , _tmp_cp_ret13)), ((void *(*)(void *__anonymous_object1846))(&_thunk4))))) , _tmp_cp_ret14));
     ((void)(_tmp_cp_ret12) /* ^?{} */);
     ((void)(_tmp_cp_ret13) /* ^?{} */);
 …
     struct ofstream *_tmp_cp_ret17;
     __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), _p0);
+    }
     ((void)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1873))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1874))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1875, _Bool __anonymous_object1876))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1877))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1878, const char *__anonymous_object1879))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1880))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1883))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1884))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1887))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1888, const char *__anonymous_object1889))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1890))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1891, const char *__anonymous_object1892))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1893))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1894))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1895, const char *__anonymous_object1896, unsigned long int __anonymous_object1897))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1898, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Ul__1(((_Bool (*)(void *__anonymous_object1899))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1900))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1901, _Bool __anonymous_object1902))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1903))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1904, const char *__anonymous_object1905))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1906))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1909))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1910))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1913))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1914, const char *__anonymous_object1915))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1916))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1917, const char *__anonymous_object1918))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1919))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1920))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1921, const char *__anonymous_object1922, unsigned long int __anonymous_object1923))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1924, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), (((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1925))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1926))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1927, _Bool __anonymous_object1928))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1929))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1930, const char *__anonymous_object1931))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1932))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1935))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1936))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1939))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1940, const char *__anonymous_object1941))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1942))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1943, const char *__anonymous_object1944))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1945))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1946))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1947, const char *__anonymous_object1948, unsigned long int __anonymous_object1949))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1950, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), __sout__P9sofstream_1, "size_t"))) , _tmp_cp_ret15), __v__Ul_1))) , _tmp_cp_ret16), ((void *(*)(void *__anonymous_object1951))(&_thunk5))))) , _tmp_cp_ret17));
+        return __endl__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PFPd0_Pd0___1(((_Bool (*)(void *__anonymous_object1873))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1874))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1875, _Bool __anonymous_object1876))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1877))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1878, const char *__anonymous_object1879))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1880))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1881, _Bool __anonymous_object1882))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1883))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1884))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1885))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1887))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1888, const char *__anonymous_object1889))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1890))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1891, const char *__anonymous_object1892))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1893))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1894))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1895, const char *__anonymous_object1896, unsigned long int __anonymous_object1897))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1898, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0Ul__1(((_Bool (*)(void *__anonymous_object1899))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1900))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1901, _Bool __anonymous_object1902))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1903))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1904, const char *__anonymous_object1905))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1906))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1907, _Bool __anonymous_object1908))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1909))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1910))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1911))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1913))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1914, const char *__anonymous_object1915))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1916))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1917, const char *__anonymous_object1918))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1919))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1920))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1921, const char *__anonymous_object1922, unsigned long int __anonymous_object1923))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1924, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Pd0___sepReset__PF_Pd0___sepReset__PF_Pd0b___sepGetCur__PFPCc_Pd0___sepSetCur__PF_Pd0PCc___getNL__PFb_Pd0___setNL__PF_Pd0b___sepOn__PF_Pd0___sepOff__PF_Pd0___sepDisable__PFb_Pd0___sepEnable__PFb_Pd0___sepGet__PFPCc_Pd0___sepSet__PF_Pd0PCc___sepGetTuple__PFPCc_Pd0___sepSetTuple__PF_Pd0PCc___fail__PFi_Pd0___flush__PFi_Pd0___open__PF_Pd0PCcPCc___close__PF_Pd0___write__PFPd0_Pd0PCcUl___fmt__PFi_Pd0PCc__FPd0_Pd0PCc__1(((_Bool (*)(void *__anonymous_object1925))__sepPrt__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1926))__sepReset__F_P9sofstream__1), ((void (*)(void *__anonymous_object1927, _Bool __anonymous_object1928))__sepReset__F_P9sofstreamb__1), ((const char *(*)(void *__anonymous_object1929))__sepGetCur__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1930, const char *__anonymous_object1931))__sepSetCur__F_P9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1932))__getNL__Fb_P9sofstream__1), ((void (*)(void *__anonymous_object1933, _Bool __anonymous_object1934))__setNL__F_P9sofstreamb__1), ((void (*)(void *__anonymous_object1935))__sepOn__F_P9sofstream__1), ((void (*)(void *__anonymous_object1936))__sepOff__F_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1937))__sepDisable__Fb_P9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepEnable__Fb_P9sofstream__1), ((const char *(*)(void *__anonymous_object1939))__sepGet__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1940, const char *__anonymous_object1941))__sepSet__F_P9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1942))__sepGetTuple__FPCc_P9sofstream__1), ((void (*)(void *__anonymous_object1943, const char *__anonymous_object1944))__sepSetTuple__F_P9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1945))__fail__Fi_P9sofstream__1), ((signed int (*)(void *__anonymous_object1946))__flush__Fi_P9sofstream__1), ((void (*)(void *__os__P7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_P9sofstreamPCcPCc__1), ((void (*)(void *__os__P7tostype_1))__close__F_P9sofstream__1), ((void *(*)(void *__anonymous_object1947, const char *__anonymous_object1948, unsigned long int __anonymous_object1949))__write__FP9sofstream_P9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1950, const char *__fmt__PCc_1, ...))__fmt__Fi_P9sofstreamPCc__1), ((void *)__sout__P9sofstream_1), "size_t"))) , _tmp_cp_ret15)), __v__Ul_1))) , _tmp_cp_ret16)), ((void *(*)(void *__anonymous_object1951))(&_thunk5))))) , _tmp_cp_ret17));
     ((void)(_tmp_cp_ret15) /* ^?{} */);
     ((void)(_tmp_cp_ret16) /* ^?{} */);
 …
     ((void)0123456789.e-09L);
     ((void)0123456789.e-09DL);
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
     ((void)(-0123456789.e-09l));
     ((void)(-0123456789.e-09F));
     ((void)(-0123456789.e-09L));
     ((void)(-0123456789.e-09DL));
+    ((void)(+0123456789.e-09));
+    ((void)(+0123456789.e-09f));
+    ((void)(+0123456789.e-09l));
+    ((void)(+0123456789.e-09F));
+    ((void)(+0123456789.e-09L));
+    ((void)(+0123456789.e-09DL));
     ((void)(-0123456789.e-09));
     ((void)(-0123456789.e-09f));
 …
     ((void)0123456789.0123456789E-09L);
     ((void)0123456789.0123456789E-09DL);
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
     ((void)(-0123456789.0123456789E-09l));
     ((void)(-0123456789.0123456789E-09F));
     ((void)(-0123456789.0123456789E-09L));
     ((void)(-0123456789.0123456789E-09DL));
+    ((void)(+0123456789.0123456789E-09));
+    ((void)(+0123456789.0123456789E-09f));
+    ((void)(+0123456789.0123456789E-09l));
+    ((void)(+0123456789.0123456789E-09F));
+    ((void)(+0123456789.0123456789E-09L));
+    ((void)(+0123456789.0123456789E-09DL));
     ((void)(-0123456789.0123456789E-09));
     ((void)(-0123456789.0123456789E-09f));
 …
     ((void)0x0123456789.p-09F);
     ((void)0x0123456789.p-09L);
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
     ((void)(-0x0123456789.p-09l));
     ((void)(-0x0123456789.p-09F));
     ((void)(-0x0123456789.p-09L));
+    ((void)(+0x0123456789.p-09));
+    ((void)(+0x0123456789.p-09f));
+    ((void)(+0x0123456789.p-09l));
+    ((void)(+0x0123456789.p-09F));
+    ((void)(+0x0123456789.p-09L));
     ((void)(-0x0123456789.p-09));
     ((void)(-0x0123456789.p-09f));
 …
     ((void)0x.0123456789P-09F);
     ((void)0x.0123456789P-09L);
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
     ((void)(-0x.0123456789P-09l));
     ((void)(-0x.0123456789P-09F));
     ((void)(-0x.0123456789P-09L));
+    ((void)(+0x.0123456789P-09));
+    ((void)(+0x.0123456789P-09f));
+    ((void)(+0x.0123456789P-09l));
+    ((void)(+0x.0123456789P-09F));
+    ((void)(+0x.0123456789P-09L));
     ((void)(-0x.0123456789P-09));
     ((void)(-0x.0123456789P-09f));
 …
     ((void)0X0123456789.0123456789P-09F);
     ((void)0X0123456789.0123456789P-09L);
+    ((void)(+0X0123456789.0123456789P-09));
+    ((void)(+0X0123456789.0123456789P-09f));
+    ((void)(+0X0123456789.0123456789P-09l));
+    ((void)(+0X0123456789.0123456789P-09F));
+    ((void)(+0X0123456789.0123456789P-09L));
     ((void)(-0X0123456789.0123456789P-09));
     ((void)(-0X0123456789.0123456789P-09f));
 …
     ((void)(-0X0123456789.0123456789P-09F));
     ((void)(-0X0123456789.0123456789P-09L));
+    ((void)(-0X0123456789.0123456789P-09));
+    ((void)(-0X0123456789.0123456789P-09f));
+    ((void)(-0X0123456789.0123456789P-09l));
+    ((void)(-0X0123456789.0123456789P-09F));
+    ((void)(-0X0123456789.0123456789P-09L));
+    ((void)((signed char )01234567));
+    ((void)((signed short int )01234567));
+    ((void)((signed int )01234567));
+    ((void)((signed long int )01234567));
+    ((void)((__int128 )01234567));
+    ((void)((unsigned char )01234567u));
+    ((void)((signed short int )01234567u));
+    ((void)((unsigned int )01234567u));
+    ((void)((signed long int )01234567u));
+    ((void)((__int128 )01234567u));
+    ((void)(+((signed int )((signed char )01234567))));
+    ((void)(+((signed int )((signed short int )01234567))));
+    ((void)(+((signed int )01234567)));
+    ((void)(+((signed long int )01234567)));
+    ((void)(+((float )((__int128 )01234567))));
+    ((void)(+((signed int )((unsigned char )01234567u))));
+    ((void)(+((signed int )((signed short int )01234567u))));
+    ((void)(+((unsigned int )01234567u)));
+    ((void)(+((signed long int )01234567u)));
+    ((void)(+((float )((__int128 )01234567u))));
+    ((void)(-((signed int )((signed char )01234567))));
+    ((void)(-((signed int )((signed short int )01234567))));
+    ((void)(-((signed int )01234567)));
+    ((void)(-((signed long int )01234567)));
+    ((void)(-((float )((__int128 )01234567))));
+    ((void)(-((signed int )((unsigned char )01234567u))));
+    ((void)(-((signed int )((signed short int )01234567u))));
+    ((void)(-((unsigned int )01234567u)));
+    ((void)(-((signed long int )01234567u)));
+    ((void)(-((float )((__int128 )01234567u))));
+    ((void)((signed char )1234567890));
+    ((void)((signed short int )1234567890));
+    ((void)((signed int )1234567890));
+    ((void)((signed long int )1234567890));
+    ((void)((__int128 )1234567890));
+    ((void)((signed char )1234567890U));
+    ((void)((unsigned short int )1234567890U));
+    ((void)((signed int )1234567890U));
+    ((void)((unsigned long int )1234567890u));
+    ((void)((unsigned __int128 )1234567890u));
+    ((void)(+((signed int )((signed char )1234567890))));
+    ((void)(+((signed int )((signed short int )1234567890))));
+    ((void)(+((signed int )1234567890)));
+    ((void)(+((signed long int )1234567890)));
+    ((void)(+((float )((__int128 )1234567890))));
+    ((void)(+((signed int )((signed char )1234567890U))));
+    ((void)(+((signed int )((unsigned short int )1234567890U))));
+    ((void)(+((signed int )1234567890U)));
+    ((void)(+((unsigned long int )1234567890u)));
+    ((void)(+((float )((unsigned __int128 )1234567890u))));
+    ((void)(-((signed int )((signed char )1234567890))));
+    ((void)(-((signed int )((signed short int )1234567890))));
+    ((void)(-((signed int )1234567890)));
+    ((void)(-((signed long int )1234567890)));
+    ((void)(-((float )((__int128 )1234567890))));
+    ((void)(-((signed int )((signed char )1234567890U))));
+    ((void)(-((signed int )((unsigned short int )1234567890U))));
+    ((void)(-((signed int )1234567890U)));
+    ((void)(-((unsigned long int )1234567890u)));
+    ((void)(-((float )((unsigned __int128 )1234567890u))));
+    ((void)((signed char )0x0123456789abcdef));
+    ((void)((signed short int )0x0123456789abcdef));
+    ((void)((signed int )0x0123456789abcdef));
+    ((void)((signed long int )0x0123456789abcdef));
+    ((void)((signed char )0x0123456789abcdefu));
+    ((void)((unsigned short int )0x0123456789abcdefu));
+    ((void)((signed int )0x0123456789abcdefu));
+    ((void)((unsigned long int )0x0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(+((signed int )0x0123456789abcdef)));
+    ((void)(+((signed long int )0x0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(+((signed int )0x0123456789abcdefu)));
+    ((void)(+((unsigned long int )0x0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0x0123456789abcdef))));
+    ((void)(-((signed int )0x0123456789abcdef)));
+    ((void)(-((signed long int )0x0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0x0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789abcdefu))));
+    ((void)(-((signed int )0x0123456789abcdefu)));
+    ((void)(-((unsigned long int )0x0123456789abcdefu)));
+    ((void)((signed char )0x0123456789ABCDEF));
+    ((void)((signed short int )0x0123456789ABCDEF));
+    ((void)((signed int )0x0123456789ABCDEF));
+    ((void)((signed long int )0x0123456789ABCDEF));
+    ((void)((signed char )0x0123456789ABCDEFu));
+    ((void)((unsigned short int )0x0123456789ABCDEFu));
+    ((void)((signed int )0x0123456789ABCDEFu));
+    ((void)((unsigned long int )0x0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(+((signed int )0x0123456789ABCDEF)));
+    ((void)(+((signed long int )0x0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(+((signed int )0x0123456789ABCDEFu)));
+    ((void)(+((unsigned long int )0x0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0x0123456789ABCDEF))));
+    ((void)(-((signed int )0x0123456789ABCDEF)));
+    ((void)(-((signed long int )0x0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0x0123456789ABCDEFu))));
+    ((void)(-((signed int )0x0123456789ABCDEFu)));
+    ((void)(-((unsigned long int )0x0123456789ABCDEFu)));
+    ((void)((signed char )0X0123456789abcdef));
+    ((void)((signed short int )0X0123456789abcdef));
+    ((void)((signed int )0X0123456789abcdef));
+    ((void)((signed long int )0X0123456789abcdef));
+    ((void)((signed char )0X0123456789abcdefu));
+    ((void)((unsigned short int )0X0123456789abcdefu));
+    ((void)((signed int )0X0123456789abcdefu));
+    ((void)((unsigned long int )0X0123456789abcdefu));
+    ((void)(+((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(+((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(+((signed int )0X0123456789abcdef)));
+    ((void)(+((signed long int )0X0123456789abcdef)));
+    ((void)(+((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(+((signed int )0X0123456789abcdefu)));
+    ((void)(+((unsigned long int )0X0123456789abcdefu)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdef))));
+    ((void)(-((signed int )((signed short int )0X0123456789abcdef))));
+    ((void)(-((signed int )0X0123456789abcdef)));
+    ((void)(-((signed long int )0X0123456789abcdef)));
+    ((void)(-((signed int )((signed char )0X0123456789abcdefu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789abcdefu))));
+    ((void)(-((signed int )0X0123456789abcdefu)));
+    ((void)(-((unsigned long int )0X0123456789abcdefu)));
+    ((void)((signed char )0X0123456789ABCDEF));
+    ((void)((signed short int )0X0123456789ABCDEF));
+    ((void)((signed int )0X0123456789ABCDEF));
+    ((void)((signed long int )0X0123456789ABCDEF));
+    ((void)((signed char )0X0123456789ABCDEFu));
+    ((void)((unsigned short int )0X0123456789ABCDEFu));
+    ((void)((signed int )0X0123456789ABCDEFu));
+    ((void)((unsigned long int )0X0123456789ABCDEFu));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(+((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(+((signed int )0X0123456789ABCDEF)));
+    ((void)(+((signed long int )0X0123456789ABCDEF)));
+    ((void)(+((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(+((signed int )0X0123456789ABCDEFu)));
+    ((void)(+((unsigned long int )0X0123456789ABCDEFu)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEF))));
+    ((void)(-((signed int )((signed short int )0X0123456789ABCDEF))));
+    ((void)(-((signed int )0X0123456789ABCDEF)));
+    ((void)(-((signed long int )0X0123456789ABCDEF)));
+    ((void)(-((signed int )((signed char )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )((unsigned short int )0X0123456789ABCDEFu))));
+    ((void)(-((signed int )0X0123456789ABCDEFu)));
+    ((void)(-((unsigned long int )0X0123456789ABCDEFu)));
+    ((void)((float )0123456789.));
+    ((void)((double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)((long double )0123456789.));
+    ((void)(+((float )0123456789.)));
+    ((void)(+((double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(+((long double )0123456789.)));
+    ((void)(-((float )0123456789.)));
+    ((void)(-((double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)(-((long double )0123456789.)));
+    ((void)((float )0123456789.e09));
+    ((void)((double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)((long double )0123456789.e09));
+    ((void)(+((float )0123456789.e+09)));
+    ((void)(+((double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(+((long double )0123456789.e+09)));
+    ((void)(-((float )0123456789.e-09)));
+    ((void)(-((double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)(-((long double )0123456789.e-09)));
+    ((void)((float ).0123456789e09));
+    ((void)((double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)((long double ).0123456789e09));
+    ((void)(+((float ).0123456789E+09)));
+    ((void)(+((double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(+((long double ).0123456789E+09)));
+    ((void)(-((float ).0123456789E-09)));
+    ((void)(-((double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)(-((long double ).0123456789E-09)));
+    ((void)((float )0123456789.0123456789));
+    ((void)((double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)((long double )0123456789.0123456789));
+    ((void)(+((float )0123456789.0123456789E09)));
+    ((void)(+((double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(+((long double )0123456789.0123456789E09)));
+    ((void)(-((float )0123456789.0123456789E+09)));
+    ((void)(-((double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)(-((long double )0123456789.0123456789E+09)));
+    ((void)((float )0123456789.0123456789E-09));
+    ((void)((double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((long double )0123456789.0123456789E-09));
+    ((void)((float )0x0123456789.p09));
+    ((void)((double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)((long double )0x0123456789.p09));
+    ((void)(+((float )0x0123456789.p09)));
+    ((void)(+((double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(+((long double )0x0123456789.p09)));
+    ((void)(-((float )0x0123456789.p09)));
+    ((void)(-((double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)(-((long double )0x0123456789.p09)));
+    ((void)((float )0x0123456789.p+09));
+    ((void)((double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)((long double )0x0123456789.p+09));
+    ((void)(+((float )0x0123456789.p-09)));
+    ((void)(+((double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(+((long double )0x0123456789.p-09)));
+    ((void)(-((float )0x.0123456789p09)));
+    ((void)(-((double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
+    ((void)(-((long double )0x.0123456789p09)));
     ((void)__f__F_c__1('a'));
     ((void)__f__F_Sc__1(20));
 …
     ((void)L"a" "b" "c");
     ((void)(___retval_main__i_1=0) /* ?{} */);
     return ((signed int )___retval_main__i_1);
+    return ___retval_main__i_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return __main__Fi___1(); }
 …
     ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
     ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((signed int )___retval_main__i_1);
+}
+    return ___retval_main__i_1;
+}

src/tests/.expect/castError.txt

-              r78315272
+              r3f7e12cb
+castError.c:7:1 error: Cannot choose between 3 alternatives for expression Cast of:
+castError.c:7:1 error: Cannot choose between 3 alternatives for expression
+Cast of:
   Name: f
+... to:
+  charAlternatives are:
+Cost ( 1, 0, 0, 0 ): Cast of:
+     Variable Expression: f: signed int
+   ... to:
+     char
+ (types:
+   char
+ )
+ Environment:
+to:
+  char
+Alternatives are:        Cost ( 1, 0, 0, 0 ): Cast of:
+          Variable Expression: f: function
+                accepting unspecified arguments
+              returning
+                nothing
+Cost ( 1, 0, 0, 0 ): Cast of:
+     Variable Expression: f: double
+   ... to:
+     char
+ (types:
+   char
+ )
+ Environment:
+Cost ( 1, 0, 0, 0 ): Cast of:
+     Variable Expression: f: function
+       accepting unspecified arguments
+     ... returning nothing
+   ... to:
+     char
+ (types:
+   char
+ )
+ Environment:
-        to:
-          char
-(types:
-            char
+)
-        Environment:
-        Cost ( 1, 0, 0, 0 ): Cast of:
-          Variable Expression: f: signed int
-        to:
-          char
-(types:
-            char
+)
-        Environment:
-        Cost ( 1, 0, 0, 0 ): Cast of:
-          Variable Expression: f: double
-        to:
-          char
-(types:
-            char
+)
-        Environment:

src/tests/.expect/scopeErrors.txt

-              r78315272
+              r3f7e12cb
 scopeErrors.c:2:1 error: duplicate object definition for thisIsAnError: signed int
 scopeErrors.c:20:1 error: duplicate function definition for butThisIsAnError: function
+  with parameters
+    double
+  returning
+    _retval_butThisIsAnError:       Attribute with name: unused
+double
+  with body
+    CompoundStmt
+... with parameters
+  double
+... returning
+  _retval_butThisIsAnError: double
+  ... with attributes:
+    Attribute with name: unused
+... with body
+  CompoundStmt

src/tests/Makefile.am

-              r78315272
+              r3f7e12cb
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Mon Sep 11 16:17:16 2017
 ## Update Count     : 45
+## Last Modified On : Tue Oct 10 14:04:40 2017
+## Update Count     : 47
 ###############################################################################
 …
 concurrent = yes
 quick_test += coroutine thread monitor
+concurrent_test = coroutine thread monitor multi-monitor sched-int-barge sched-int-block sched-int-disjoint sched-int-wait sched-ext sched-ext-multi preempt
+concurrent_test =               \
+        coroutine               \
+        fmtLines                \
+        pingpong                \
+        prodcons                \
+        thread                  \
+        matrixSum               \
+        monitor                 \
+        multi-monitor           \
+        boundedBuffer           \
+        preempt                 \
+        sched-int-block         \
+        sched-int-disjoint      \
+        sched-int-wait          \
+        sched-ext-barge         \
+        sched-ext-dtor          \
+        sched-ext-else          \
+        sched-ext-parse         \
+        sched-ext-recurse       \
+        sched-ext-statment      \
+        sched-ext-when
 else
 concurrent=no
 …
 declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 gccExtensions : gccExtensions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 extension : extension.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 attributes : attributes.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 KRfunctions : KRfunctions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 literals : literals.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
 …
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+typedefRedef-ERR1: typedefRedef.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/Makefile.in

-              r78315272
+              r3f7e12cb
 @BUILD_CONCURRENCY_TRUE@concurrent = yes
 @BUILD_CONCURRENCY_FALSE@concurrent_test =
+@BUILD_CONCURRENCY_TRUE@concurrent_test = coroutine thread monitor multi-monitor sched-int-barge sched-int-block sched-int-disjoint sched-int-wait sched-ext sched-ext-multi preempt
+@BUILD_CONCURRENCY_TRUE@concurrent_test = \
+@BUILD_CONCURRENCY_TRUE@        coroutine               \
+@BUILD_CONCURRENCY_TRUE@        fmtLines                \
+@BUILD_CONCURRENCY_TRUE@        pingpong                \
+@BUILD_CONCURRENCY_TRUE@        prodcons                \
+@BUILD_CONCURRENCY_TRUE@        thread                  \
+@BUILD_CONCURRENCY_TRUE@        matrixSum               \
+@BUILD_CONCURRENCY_TRUE@        monitor                 \
+@BUILD_CONCURRENCY_TRUE@        multi-monitor           \
+@BUILD_CONCURRENCY_TRUE@        boundedBuffer           \
+@BUILD_CONCURRENCY_TRUE@        preempt                 \
+@BUILD_CONCURRENCY_TRUE@        sched-int-block         \
+@BUILD_CONCURRENCY_TRUE@        sched-int-disjoint      \
+@BUILD_CONCURRENCY_TRUE@        sched-int-wait          \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-barge         \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-dtor          \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-else          \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-parse         \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-recurse       \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-statment      \
+@BUILD_CONCURRENCY_TRUE@        sched-ext-when
 # applies to both programs
 …
 declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 gccExtensions : gccExtensions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 extension : extension.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 attributes : attributes.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 KRfunctions : KRfunctions.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 literals : literals.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+sched-ext-parse : sched-ext-parse.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 gmp : gmp.c @CFA_BINDIR@/@CFA_NAME@
 …
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+typedefRedef-ERR1: typedefRedef.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/coroutine.c

-              r78315272
+              r3f7e12cb
 // Created On       : Thu Jun  8 07:29:37 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  8 07:37:12 2017
 // Update Count     : 5
+// Last Modified On : Sun Sep 17 21:38:15 2017
+// Update Count     : 7
 //
 …
 coroutine Fibonacci {
         int fn;                                         // used for communication
+        int fn;                                                                                         // used for communication
 };
 …
 void main( Fibonacci & this ) {
         int fn1, fn2;                                   // retained between resumes
         this.fn = 0;                                    // case 0
+        int fn1, fn2;                                                                           // retained between resumes
+        this.fn = 0;                                                                            // case 0
         fn1 = this.fn;
         suspend();                                              // return to last resume
+        suspend();                                                                                      // restart last resume
+        this.fn = 1;                                    // case 1
+        fn2 = fn1;
+        fn1 = this.fn;
+        suspend();                                              // return to last resume
+        this.fn = 1;                                                                            // case 1
+        fn2 = fn1;  fn1 = this.fn;
+        suspend();                                                                                      // restart last resume
         for ( ;; ) {                                    // general case
+        for ( ;; ) {                                                                            // general case
                 this.fn = fn1 + fn2;
+                fn2 = fn1;
+                fn1 = this.fn;
+                suspend();                                      // return to last resume
+                fn2 = fn1;  fn1 = this.fn;
+                suspend();                                                                              // restart last resume
         } // for
+}
 int next( Fibonacci & this ) {
         resume( this );                                 // transfer to last suspend
+        resume( this );                                                                         // restart last suspend
         return this.fn;
+}
 …
         Fibonacci f1, f2;
         for ( int i = 1; i <= 10; i += 1 ) {
                 sout | next( f1 ) | ' ' | next( f2 ) | endl;
+                sout | next( f1 ) | next( f2 ) | endl;
         } // for
+}

src/tests/fmtLines.c

-              r78315272
+              r3f7e12cb
 // Created On       : Sun Sep 17 21:56:15 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep 18 11:35:57 2017
 // Update Count     : 31
+// Last Modified On : Sun Oct  1 11:57:19 2017
+// Update Count     : 34
 //
 …
 void ?{}( Format & fmt ) {
     resume( fmt );                                                                              // start coroutine
+        resume( fmt );                                                                          // prime (start) coroutine
+}
 void ^?{}( Format & fmt ) {
     if ( fmt.g != 0 || fmt.b != 0 ) sout | endl;
+        if ( fmt.g != 0 || fmt.b != 0 ) sout | endl;
+}
 …
 void prt( Format & fmt, char ch ) {
     fmt.ch = ch;
     resume( fmt );
+        fmt.ch = ch;
+        resume( fmt );
 } // prt
 int main() {
         Format fmt;
+        Format fmt;                                                                                     // format characters into blocks of 4 and groups of 5 blocks per line
         char ch;
         for ( ;; ) {
+        Eof: for ( ;; ) {                                                                       // read until end of file
                 sin | ch;                                                                               // read one character
           if ( eof( sin ) ) break;                                                      // eof ?
                 prt( fmt, ch );
+          if ( eof( sin ) ) break Eof;                                          // eof ?
+                prt( fmt, ch );                                                                 // push character for formatting
         } // for
 } // main

src/tests/gmp.c

-              r78315272
+              r3f7e12cb
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Sep  4 09:51:18 2017
 // Update Count     : 550
+// Last Modified On : Thu Sep 28 18:33:51 2017
+// Update Count     : 555
 //
 …
         sout | "Factorial Numbers" | endl;
+        Int fact;
+        fact = 1;                                                                                       // 1st case
+        Int fact = 1;                                                                           // 1st case
         sout | (int)0 | fact | endl;
         for ( unsigned int i = 1; i <= 40; i += 1 ) {

src/tests/literals.c

-              r78315272
+              r3f7e12cb
 // Created On       : Sat Sep  9 16:34:38 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Sep 12 07:45:46 2017
 // Update Count     : 88
+// Last Modified On : Mon Sep 25 20:26:00 2017
+// Update Count     : 132
 //
 #ifdef __CFA__
+#include <stdint.h>
 #include <fstream>
 …
          0123456789.e-09;   0123456789.e-09f;   0123456789.e-09l;   0123456789.e-09F;   0123456789.e-09L;   0123456789.e-09DL;
         -0123456789.e-09;  -0123456789.e-09f;  -0123456789.e-09l;  -0123456789.e-09F;  -0123456789.e-09L;  -0123456789.e-09DL;
+        +0123456789.e-09;  +0123456789.e-09f;  +0123456789.e-09l;  +0123456789.e-09F;  +0123456789.e-09L;  +0123456789.e-09DL;
         -0123456789.e-09;  -0123456789.e-09f;  -0123456789.e-09l;  -0123456789.e-09F;  -0123456789.e-09L;  -0123456789.e-09DL;
 …
          0123456789.0123456789E-09;   0123456789.0123456789E-09f;   0123456789.0123456789E-09l;   0123456789.0123456789E-09F;   0123456789.0123456789E-09L;   0123456789.0123456789E-09DL;
         -0123456789.0123456789E-09;  -0123456789.0123456789E-09f;  -0123456789.0123456789E-09l;  -0123456789.0123456789E-09F;  -0123456789.0123456789E-09L;  -0123456789.0123456789E-09DL;
+        +0123456789.0123456789E-09;  +0123456789.0123456789E-09f;  +0123456789.0123456789E-09l;  +0123456789.0123456789E-09F;  +0123456789.0123456789E-09L;  +0123456789.0123456789E-09DL;
         -0123456789.0123456789E-09;  -0123456789.0123456789E-09f;  -0123456789.0123456789E-09l;  -0123456789.0123456789E-09F;  -0123456789.0123456789E-09L;  -0123456789.0123456789E-09DL;
 …
 x0123456789.p-09;   0x0123456789.p-09f;   0x0123456789.p-09l;   0x0123456789.p-09F;   0x0123456789.p-09L;
         -0x0123456789.p-09;  -0x0123456789.p-09f;  -0x0123456789.p-09l;  -0x0123456789.p-09F;  -0x0123456789.p-09L;
+        +0x0123456789.p-09;  +0x0123456789.p-09f;  +0x0123456789.p-09l;  +0x0123456789.p-09F;  +0x0123456789.p-09L;
         -0x0123456789.p-09;  -0x0123456789.p-09f;  -0x0123456789.p-09l;  -0x0123456789.p-09F;  -0x0123456789.p-09L;
 …
 x.0123456789P-09;   0x.0123456789P-09f;   0x.0123456789P-09l;   0x.0123456789P-09F;   0x.0123456789P-09L;
         -0x.0123456789P-09;  -0x.0123456789P-09f;  -0x.0123456789P-09l;  -0x.0123456789P-09F;  -0x.0123456789P-09L;
+        +0x.0123456789P-09;  +0x.0123456789P-09f;  +0x.0123456789P-09l;  +0x.0123456789P-09F;  +0x.0123456789P-09L;
         -0x.0123456789P-09;  -0x.0123456789P-09f;  -0x.0123456789P-09l;  -0x.0123456789P-09F;  -0x.0123456789P-09L;
 …
 X0123456789.0123456789P-09;   0X0123456789.0123456789P-09f;   0X0123456789.0123456789P-09l;   0X0123456789.0123456789P-09F;   0X0123456789.0123456789P-09L;
+        +0X0123456789.0123456789P-09;  +0X0123456789.0123456789P-09f;  +0X0123456789.0123456789P-09l;  +0X0123456789.0123456789P-09F;  +0X0123456789.0123456789P-09L;
         -0X0123456789.0123456789P-09;  -0X0123456789.0123456789P-09f;  -0X0123456789.0123456789P-09l;  -0X0123456789.0123456789P-09F;  -0X0123456789.0123456789P-09L;
+        -0X0123456789.0123456789P-09;  -0X0123456789.0123456789P-09f;  -0X0123456789.0123456789P-09l;  -0X0123456789.0123456789P-09F;  -0X0123456789.0123456789P-09L;
+#ifdef __CFA__
+// fixed-size length
+        // octal
+         01234567_l8;   01234567_l16;   01234567_l32;   01234567_l64;   01234567_l128;   01234567_l8u;   01234567_ul16;   01234567_l32u;   01234567_ul64;   01234567_ul128;
+        +01234567_l8;  +01234567_l16;  +01234567_l32;  +01234567_l64;  +01234567_l128;  +01234567_l8u;  +01234567_ul16;  +01234567_l32u;  +01234567_ul64;  +01234567_ul128;
+        -01234567_l8;  -01234567_l16;  -01234567_l32;  -01234567_l64;  -01234567_l128;  -01234567_l8u;  -01234567_ul16;  -01234567_l32u;  -01234567_ul64;  -01234567_ul128;
+        // decimal
+         1234567890L8;   1234567890L16;   1234567890l32;   1234567890l64;   1234567890l128;   1234567890UL8;   1234567890L16U;   1234567890Ul32;   1234567890l64u;   1234567890l128u;
+        +1234567890L8;  +1234567890L16;  +1234567890l32;  +1234567890l64;  +1234567890l128;  +1234567890UL8;  +1234567890L16U;  +1234567890Ul32;  +1234567890l64u;  +1234567890l128u;
+        -1234567890L8;  -1234567890L16;  -1234567890l32;  -1234567890l64;  -1234567890l128;  -1234567890UL8;  -1234567890L16U;  -1234567890Ul32;  -1234567890l64u;  -1234567890l128u;
+        // hexadecimal
+x0123456789abcdef_l8;   0x0123456789abcdef_l16;   0x0123456789abcdefl32;   0x0123456789abcdefl64;   0x0123456789abcdef_ul8;   0x0123456789abcdef_l16u;   0x0123456789abcdeful32;   0x0123456789abcdefl64u;
+        +0x0123456789abcdef_l8;  +0x0123456789abcdef_l16;  +0x0123456789abcdefl32;  +0x0123456789abcdefl64;  +0x0123456789abcdef_ul8;  +0x0123456789abcdef_l16u;  +0x0123456789abcdeful32;  +0x0123456789abcdefl64u;
+        -0x0123456789abcdef_l8;  -0x0123456789abcdef_l16;  -0x0123456789abcdefl32;  -0x0123456789abcdefl64;  -0x0123456789abcdef_ul8;  -0x0123456789abcdef_l16u;  -0x0123456789abcdeful32;  -0x0123456789abcdefl64u;
+x0123456789ABCDEF_l8;   0x0123456789ABCDEF_l16;   0x0123456789ABCDEFl32;   0x0123456789ABCDEFl64;   0x0123456789ABCDEF_ul8;   0x0123456789ABCDEF_l16u;   0x0123456789ABCDEFul32;   0x0123456789ABCDEFl64u;
+        +0x0123456789ABCDEF_l8;  +0x0123456789ABCDEF_l16;  +0x0123456789ABCDEFl32;  +0x0123456789ABCDEFl64;  +0x0123456789ABCDEF_ul8;  +0x0123456789ABCDEF_l16u;  +0x0123456789ABCDEFul32;  +0x0123456789ABCDEFl64u;
+        -0x0123456789ABCDEF_l8;  -0x0123456789ABCDEF_l16;  -0x0123456789ABCDEFl32;  -0x0123456789ABCDEFl64;  -0x0123456789ABCDEF_ul8;  -0x0123456789ABCDEF_l16u;  -0x0123456789ABCDEFul32;  -0x0123456789ABCDEFl64u;
+X0123456789abcdef_l8;   0X0123456789abcdef_l16;   0X0123456789abcdefl32;   0X0123456789abcdefl64;   0X0123456789abcdef_ul8;   0X0123456789abcdef_l16u;   0X0123456789abcdeful32;   0X0123456789abcdefl64u;
+        +0X0123456789abcdef_l8;  +0X0123456789abcdef_l16;  +0X0123456789abcdefl32;  +0X0123456789abcdefl64;  +0X0123456789abcdef_ul8;  +0X0123456789abcdef_l16u;  +0X0123456789abcdeful32;  +0X0123456789abcdefl64u;
+        -0X0123456789abcdef_l8;  -0X0123456789abcdef_l16;  -0X0123456789abcdefl32;  -0X0123456789abcdefl64;  -0X0123456789abcdef_ul8;  -0X0123456789abcdef_l16u;  -0X0123456789abcdeful32;  -0X0123456789abcdefl64u;
+X0123456789ABCDEF_l8;   0X0123456789ABCDEF_l16;   0X0123456789ABCDEFl32;   0X0123456789ABCDEFl64;   0X0123456789ABCDEF_ul8;   0X0123456789ABCDEF_l16u;   0X0123456789ABCDEFul32;   0X0123456789ABCDEFl64u;
+        +0X0123456789ABCDEF_l8;  +0X0123456789ABCDEF_l16;  +0X0123456789ABCDEFl32;  +0X0123456789ABCDEFl64;  +0X0123456789ABCDEF_ul8;  +0X0123456789ABCDEF_l16u;  +0X0123456789ABCDEFul32;  +0X0123456789ABCDEFl64u;
+        -0X0123456789ABCDEF_l8;  -0X0123456789ABCDEF_l16;  -0X0123456789ABCDEFl32;  -0X0123456789ABCDEFl64;  -0X0123456789ABCDEF_ul8;  -0X0123456789ABCDEF_l16u;  -0X0123456789ABCDEFul32;  -0X0123456789ABCDEFl64u;
+        // floating
+         0123456789.l32;   0123456789.l64;   0123456789.l80;   0123456789.l128;
+        +0123456789.l32;  +0123456789.l64;  +0123456789.l80;  +0123456789.l128;
+        -0123456789.l32;  -0123456789.l64;  -0123456789.l80;  -0123456789.l128;
+         0123456789.e09L32;    0123456789.e09L64;    0123456789.e09L80;    0123456789.e09L128;
+        +0123456789.e+09L32;  +0123456789.e+09L64;  +0123456789.e+09L80;  +0123456789.e+09L128;
+        -0123456789.e-09L32;  -0123456789.e-09L64;  -0123456789.e-09L80;  -0123456789.e-09L128;
+         .0123456789e09L32;    .0123456789e09L64;    .0123456789e09L80;    .0123456789e09L128;
+        +.0123456789E+09L32;  +.0123456789E+09L64;  +.0123456789E+09L80;  +.0123456789E+09L128;
+        -.0123456789E-09L32;  -.0123456789E-09L64;  -.0123456789E-09L80;  -.0123456789E-09L128;
+         0123456789.0123456789L32;       0123456789.0123456789L64;       0123456789.0123456789L80;       0123456789.0123456789L128;
+        +0123456789.0123456789E09L32;   +0123456789.0123456789E09L64;   +0123456789.0123456789E09L80;   +0123456789.0123456789E09L128;
+        -0123456789.0123456789E+09L32;  -0123456789.0123456789E+09L64;  -0123456789.0123456789E+09L80;  -0123456789.0123456789E+09L128;
+         0123456789.0123456789E-09L32;   0123456789.0123456789E-09L64;   0123456789.0123456789E-09L80;   0123456789.0123456789E-09L128;
+x0123456789.p09l32;   0x0123456789.p09l64;   0x0123456789.p09l80;   0x0123456789.p09l128;
+        +0x0123456789.p09l32;  +0x0123456789.p09l64;  +0x0123456789.p09l80;  +0x0123456789.p09l128;
+        -0x0123456789.p09l32;  -0x0123456789.p09l64;  -0x0123456789.p09l80;  -0x0123456789.p09l128;
+x0123456789.p+09l32;   0x0123456789.p+09L64;   0x0123456789.p+09L80;   0x0123456789.p+09L128;
+        +0x0123456789.p-09l32;  +0x0123456789.p-09L64;  +0x0123456789.p-09L80;  +0x0123456789.p-09L128;
+        -0x.0123456789p09l32;   -0x.0123456789p09L64;   -0x.0123456789p09L80;   -0x.0123456789p09L128;
 // char, short, int suffix overloading
-#ifdef __CFA__
         f( 'a' );
         f( 20_hh );

src/tests/prodcons.c

-              r78315272
+              r3f7e12cb
 // Created On       : Mon Sep 18 12:23:39 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Sep 20 17:03:28 2017
 // Update Count     : 40
+// Last Modified On : Mon Oct 30 23:06:05 2017
+// Update Count     : 42
 //
 #include <fstream>
 #include <coroutine>
 #include <stdlib>                                                                               // rand48
+#include <stdlib>                                                                               // random
 #include <unistd.h>                                                                             // getpid
 …
         // 1st resume starts here
         for ( int i = 0; i < prod.N; i += 1 ) {
                 int p1 = (unsigned int)rand48() % 100;                  // non-negative
                 int p2 = (unsigned int)rand48() % 100;
+                int p1 = random( 100 );
+                int p2 = random( 100 );
                 sout | p1 | " " | p2 | endl;
                 int status = delivery( *prod.c, p1, p2 );
 …
         Prod prod;
         Cons cons = { prod };
         rand48seed( /* getpid() */ 103 );                                       // fixed seed for testing
+        random_seed( /* getpid() */ 103 );                                      // fixed seed for testing
         start( prod, 5, cons );
         sout | "main stops" | endl;

src/tests/random.c

-              r78315272
+              r3f7e12cb
 // Created On       : Tue Jul  5 21:29:30 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jul  6 18:00:29 2016
 // Update Count     : 3
+// Last Modified On : Mon Oct 30 23:06:49 2017
+// Update Count     : 6
 //
 …
 int main() {
         //rand48seed( getpid() );                                                               // set random seed
         rand48seed( 1003 );                                                                     // fixed seed for repeatable tests
+        //srandom( getpid() );                                                          // set random seed
+        random_seed( 1003 );                                                            // fixed seed for repeatable tests
         // test polymorphic calls to random and stream
         char c = rand48();
+        char c = random();
         sout | c | endl;
         int i = rand48();
+        int i = random();
     sout | i | endl;
         unsigned int ui = rand48();
+        unsigned int ui = random();
     sout | ui | endl;
         long int li = rand48();
+        long int li = random();
     sout | li | endl;
         unsigned long int uli = rand48();
+        unsigned long int uli = random();
     sout | uli | endl;
     float f = rand48();
+    float f = random();
     sout | f | endl;
     double d = rand48();
+    double d = random();
     sout | d | endl;
     float _Complex fc = rand48();
+    float _Complex fc = random();
     sout | fc | endl;
     double _Complex dc = rand48();
+    double _Complex dc = random();
     sout | dc | endl;
     long double _Complex ldc = rand48();
+    long double _Complex ldc = random();
     sout | ldc | endl;
 } // main

src/tests/rational.c

-              r78315272
+              r3f7e12cb
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug 23 21:40:11 2017
 // Update Count     : 66
+// Last Modified On : Tue Oct 10 23:25:04 2017
+// Update Count     : 67
 //

src/tests/sched-ext-parse.c

-              r78315272
+              r3f7e12cb
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
+//
+//              DEPRECATED TEST
+//              DIFFERS BETWEEN DEBUG AND RELEASE
+//
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
 #include <monitor>
 …
 ;
+        }
         or waitfor( f1, a, a ) {
+        or waitfor( f2, a, a ) {
 ;
+        }

src/tests/sched-ext.c

-              r78315272
+              r3f7e12cb
 volatile bool done;
-unsigned rand10() {
-        return (unsigned)rand48() % 10;
+}
 //----------------------------------------------------------------------------------------------------
 // Acceptor
 …
 void do_wait( global_t * mutex a ) {
         sout | "Waiting to accept" | endl;
         yield( rand10() );
+        yield( random( 10 ) );
         sout | "Accepting" | endl;
 …
         acceptable.monitors      = &a;
         __accept_internal( 1, &acceptable );
+        __waitfor_internal( 1, &acceptable );
         sout | "Accepted" | endl;
         yield( rand10() );
+        yield( random( 10 ) );
+}
 …
 void main( Acceptee* this ) {
         while( !done ) {
                 yield( rand10() );
+                yield( random( 10 ) );
                 do_notify( &globalA );
                 yield( rand10() );
+                yield( random( 10 ) );
+        }
+}
 …
 int main(int argc, char* argv[]) {
         done = false;
         rand48seed( time( NULL ) );
+        random_seed( time( NULL ) );
         printf("%p\n", &globalA);
         sout | "Starting" | endl;

src/tests/sched-int-barge.c

-              r78315272
+              r3f7e12cb
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
+//
+//              DEPRECATED TEST
+//
+//----------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------
 #include <fstream>
 #include <kernel>
 …
         if( action == 0 ) {
                 c.do_signal = max( ((unsigned)rand48()) % 10, 1);
                 c.do_wait1 = ((unsigned)rand48()) % (c.do_signal);
                 c.do_wait2 = ((unsigned)rand48()) % (c.do_signal);
+                c.do_signal = max( random( 10 ), 1);
+                c.do_wait1 = random( c.do_signal );
+                c.do_wait2 = random( c.do_signal );
                 if(c.do_wait1 == c.do_wait2) sout | "Same" | endl;
 …
         if( action == c.do_wait1 || action == c.do_wait2 ) {
                 c.state = WAIT;
                 wait( &cond );
+                wait( cond );
                 if(c.state != SIGNAL) {
 …
                 c.state = SIGNAL;
                 signal( &cond );
                 signal( &cond );
+                signal( cond );
+                signal( cond );
+        }
         else {
 …
 int main(int argc, char* argv[]) {
         rand48seed(0);
+        random_seed(0);
         processor p;
+        {

src/tests/sched-int-block.c

-              r78315272
+              r3f7e12cb
+//---------------------------------------------------------
+// Barging test
+// Ensures that no barging can occur between :
+//   - the frontend of the signal_block and the signaled thread
+//   - the signaled  threadand the backend of the signal_block
+//---------------------------------------------------------
 #include <fstream>
 #include <kernel>
 …
 //------------------------------------------------------------------------------
 void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
         wait( &cond, (uintptr_t)this_thread );
+        wait( cond, (uintptr_t)this_thread );
         yield( ((unsigned)rand48()) % 10 );
+        yield( random( 10 ) );
         if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
 …
         a.last_thread = b.last_thread = this_thread;
         yield( ((unsigned)rand48()) % 10 );
+        yield( random( 10 ) );
+}
 …
 //------------------------------------------------------------------------------
 void signal_op( global_data_t & mutex a, global_data_t & mutex b ) {
         yield( ((unsigned)rand48()) % 10 );
+        yield( random( 10 ) );
         [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
         if( !is_empty( &cond ) ) {
+        if( !is_empty( cond ) ) {
                 thread_desc * next = front( &cond );
+                thread_desc * next = front( cond );
                 if( ! signal_block( &cond ) ) {
+                if( ! signal_block( cond ) ) {
                         sout | "ERROR expected to be able to signal" | endl;
                         abort();
+                }
                 yield( ((unsigned)rand48()) % 10 );
+                yield( random( 10 ) );
                 if(a.last_thread != next || b.last_thread != next) {
 …
 int main(int argc, char* argv[]) {
         rand48seed( time( NULL ) );
+        random_seed( time( NULL ) );
         done = false;
         processor p;

src/tests/sched-int-disjoint.c

-              r78315272
+              r3f7e12cb
 // Waiting logic
 bool wait( global_t & mutex m, global_data_t & mutex d ) {
         wait( &cond );
+        wait( cond );
         if( d.state != SIGNAL ) {
                 sout | "ERROR barging!" | endl;
 …
 //------------------------------------------------------------------------------
 // Signalling logic
 void signal( condition * cond, global_t & mutex a, global_data_t & mutex b ) {
+void signal( condition & cond, global_t & mutex a, global_data_t & mutex b ) {
         b.state = SIGNAL;
         signal( cond );
 …
 void logic( global_t & mutex a ) {
         signal( &cond, a, data );
+        signal( cond, a, data );
         yield( (unsigned)rand48() % 10 );
+        yield( random( 10 ) );
         //This is technically a mutual exclusion violation but the mutex monitor protects us
 …
 // Main loop
 int main(int argc, char* argv[]) {
         rand48seed( time( NULL ) );
+        random_seed( time( NULL ) );
         all_done = false;
         processor p;

src/tests/sched-int-wait.c

-              r78315272
+              r3f7e12cb
+//---------------------------------------------------------
+// Multi wait test
+// Ensures that no deadlock from waiting/signalling conditions
+//---------------------------------------------------------
 #include <fstream>
 #include <kernel>
 …
 //----------------------------------------------------------------------------------------------------
 // Tools
 void signal( condition * cond, global_t & mutex a, global_t & mutex b ) {
+void signal( condition & cond, global_t & mutex a, global_t & mutex b ) {
         signal( cond );
+}
 void signal( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+void signal( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
         signal( cond );
+}
 void wait( condition * cond, global_t & mutex a, global_t & mutex b ) {
+void wait( condition & cond, global_t & mutex a, global_t & mutex b ) {
         wait( cond );
+}
 void wait( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
+void wait( condition & cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
         wait( cond );
+}
 …
         while( waiter_left != 0 ) {
                 unsigned action = (unsigned)rand48() % 4;
+                unsigned action = random( 4 );
                 switch( action ) {
                         case 0:
                                 signal( &condABC, globalA, globalB, globalC );
+                                signal( condABC, globalA, globalB, globalC );
                                 break;
                         case 1:
                                 signal( &condAB , globalA, globalB );
+                                signal( condAB , globalA, globalB );
                                 break;
                         case 2:
                                 signal( &condBC , globalB, globalC );
+                                signal( condBC , globalB, globalC );
                                 break;
                         case 3:
                                 signal( &condAC , globalA, globalC );
+                                signal( condAC , globalA, globalC );
                                 break;
                         default:
 …
 void main( WaiterABC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condABC, globalA, globalB, globalC );
+                wait( condABC, globalA, globalB, globalC );
+        }
 …
 void main( WaiterAB & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condAB , globalA, globalB );
+                wait( condAB , globalA, globalB );
+        }
 …
 void main( WaiterAC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condAC , globalA, globalC );
+                wait( condAC , globalA, globalC );
+        }
 …
 void main( WaiterBC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condBC , globalB, globalC );
+                wait( condBC , globalB, globalC );
+        }
 …
 // Main
 int main(int argc, char* argv[]) {
         rand48seed( time( NULL ) );
+        random_seed( time( NULL ) );
         waiter_left = 4;
         processor p[2];

src/tests/thread.c

-              r78315272
+              r3f7e12cb
                 yield();
+        }
         V(this.lock);
+        V(*this.lock);
+}
 void main(Second& this) {
         P(this.lock);
+        P(*this.lock);
         for(int i = 0; i < 10; i++) {
                 sout | "Second : Suspend No." | i + 1 | endl;

Context Navigation

Changes in / [78315272:3f7e12cb]

Legend: