Changeset eba74ba

doc/bibliography/pl.bib

-              r3ef35bd
+              reba74ba
+}
+@article{Hoare61,
+    keywords    = {quick sort},
+    contributer = {pabuhr@plg},
+    author      = {C. A. R. Hoare},
+    title       = {Algorithms 63/64: Partition/Quicksort},
+    journal     = cacm,
+    volume      = 4,
+    number      = 7,
+    month       = jul,
+    year        = 1961,
+    pages       = {321},
+}
 @article{Cormack81,
     keywords    = {},
 …
     year        = 2008,
     pages       = {8-15},
+}
+@article{Joung00,
+    author      = {Joung, Yuh-Jzer},
+    title       = {Asynchronous group mutual exclusion},
+    journal     = {Distributed Computing},
+    year        = {2000},
+    month       = {Nov},
+    volume      = {13},
+    number      = {4},
+    pages       = {189--206},
+}
 …
 @manual{Python,
     keywords    = {Python},
     contributer = {pabuhr},
+    contributer = {pabuhr@plg},
     title       = {Python Reference Manual, Release 2.5},
     author      = {Guido van Rossum},
 …
+}
+@article{Hoare61,
+    keywords    = {quick sort},
+    contributer = {pabuhr@plg},
+    author      = {C. A. R. Hoare},
+    title       = {Algorithms 63/64: Partition/Quicksort},
+    journal     = cacm,
+    volume      = 4,
+    number      = 7,
+    month       = jul,
+    year        = 1961,
+    pages       = {321},
+@article{Nakaike15,
+    keywords    = {hardware transactional memory},
+    contributer = {pabuhr@plg},
+    author      = {Nakaike, Takuya and Odaira, Rei and Gaudet, Matthew and Michael, Maged M. and Tomari, Hisanobu},
+    title       = {Quantitative Comparison of Hardware Transactional Memory for Blue Gene/Q, zEnterprise {EC12}, {I}ntel Core, and {POWER8}},
+    journal     = {SIGARCH Comput. Archit. News},
+    volume      = {43},
+    number      = {3},
+    month       = jun,
+    year        = {2015},
+    pages       = {144--157},
+    publisher   = {ACM},
+    address     = {New York, NY, USA},
+}

doc/papers/concurrency/Paper.tex

-              r3ef35bd
+              reba74ba
 %\DeclareTextCommandDefault{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.1ex}}}
 \renewcommand{\textunderscore}{\leavevmode\makebox[1.2ex][c]{\rule{1ex}{0.075ex}}}
-%\def\myCHarFont{\fontencoding{T1}\selectfont}%
-% \def\{{\ttfamily\upshape\myCHarFont \char`\}}}%
 \renewcommand*{\thefootnote}{\Alph{footnote}} % hack because fnsymbol does not work
 …
 The coroutine main's stack holds the state for the next generation, @f1@ and @f2@, and the code has the three suspend points, representing the three states in the Fibonacci formula, to context switch back to the caller's resume.
 The interface function, @next@, takes a Fibonacci instance and context switches to it using @resume@;
 on return, the Fibonacci field, @fn@, contains the next value in the sequence, which is returned.
+on restart, the Fibonacci field, @fn@, contains the next value in the sequence, which is returned.
 The first @resume@ is special because it cocalls the coroutine at its coroutine main and allocates the stack;
 when the coroutine main returns, its stack is deallocated.
 Hence, @Fib@ is an object at creation, transitions to a coroutine on its first resume, and transitions back to an object when the coroutine main finishes.
 Figure~\ref{f:Coroutine1State} shows the coroutine version of the C version in Figure~\ref{f:ExternalState}.
 Coroutine generators are called \newterm{output coroutines} because values are returned by the coroutine.
 Figure~\ref{f:CFAFmt} shows an \newterm{input coroutine}, @Format@, for restructuring text into groups of character blocks of fixed size.
+Coroutine generators are called \newterm{output coroutines} because values are only returned.
+Figure~\ref{f:CFAFmt} shows an \newterm{input coroutine}, @Format@, for restructuring text into groups of characters of fixed-size blocks.
 For example, the input of the left is reformatted into the output on the right.
 \begin{quote}
 …
 \end{tabular}
 \end{quote}
 The example takes advantage of resuming coroutines in the constructor to prime the coroutine loops so the first character sent for formatting appears inside the nested loops.
+The example takes advantage of resuming a coroutine in the constructor to prime the loops so the first character sent for formatting appears inside the nested loops.
 The destruction provides a newline if formatted text ends with a full line.
 Figure~\ref{f:CFmt} shows the C equivalent formatter, where the loops of the coroutine are flatten (linearized) and rechecked on each call because execution location is not retained between calls.
 …
 void main( Format & fmt ) with( fmt ) {
         for ( ;; ) {
                 for ( g = 0; g < 5; g += 1 ) {  // group
+                for ( g = 0; g < 5; g += 1 ) {      // group
                         for ( b = 0; b < 4; b += 1 ) { // block
                                 `suspend();`
 …
 };
 void format( struct Format * fmt ) {
         if ( fmt->ch != -1 ) { // not EOF
+        if ( fmt->ch != -1 ) {      // not EOF ?
                 printf( "%c", fmt->ch );
                 fmt->b += 1;
 …
+                }
                 if ( fmt->g == 5 ) {  // group
                         printf( "\n" );      // separator
+                        printf( "\n" );     // separator
                         fmt->g = 0;
+                }
 …
 The previous examples are \newterm{asymmetric (semi) coroutine}s because one coroutine always calls a resuming function for another coroutine, and the resumed coroutine always suspends back to its last resumer, similar to call/return for normal functions.
 However, there is no stack growth because @resume@/@suspend@ context switch to an existing stack frames rather than create a new one.
 \newterm{Symmetric (full) coroutine}s have a coroutine call a resuming function for another coroutine, which eventually forms a cycle.
+However, there is no stack growth because @resume@/@suspend@ context switch to existing stack-frames rather than create new ones.
+\newterm{Symmetric (full) coroutine}s have a coroutine call a resuming function for another coroutine, which eventually forms a resuming-call cycle.
 (The trivial cycle is a coroutine resuming itself.)
 This control flow is similar to recursion for normal routines, but again there is no stack growth from the context switch.
 …
 The @start@ function communicates both the number of elements to be produced and the consumer into the producer's coroutine structure.
 Then the @resume@ to @prod@ creates @prod@'s stack with a frame for @prod@'s coroutine main at the top, and context switches to it.
 @prod@'s coroutine main starts, creates local variables that are retained between coroutine activations, and executes $N$ iterations, each generating two random vales, calling the consumer to deliver the values, and printing the status returned from the consumer.
+@prod@'s coroutine main starts, creates local variables that are retained between coroutine activations, and executes $N$ iterations, each generating two random values, calling the consumer to deliver the values, and printing the status returned from the consumer.
 The producer call to @delivery@ transfers values into the consumer's communication variables, resumes the consumer, and returns the consumer status.
 For the first resume, @cons@'s stack is initialized, creating local variables retained between subsequent activations of the coroutine.
 The consumer iterates until the @done@ flag is set, prints, increments status, and calls back to the producer's @payment@ member, and on return prints the receipt from the producer and increments the money for the next payment.
 The call from the consumer to the producer's @payment@ member introduces the cycle between producer and consumer.
+The consumer iterates until the @done@ flag is set, prints, increments status, and calls back to the producer via @payment@, and on return from @payment@, prints the receipt from the producer and increments @money@ (inflation).
+The call from the consumer to the @payment@ introduces the cycle between producer and consumer.
 When @payment@ is called, the consumer copies values into the producer's communication variable and a resume is executed.
 The context switch restarts the producer at the point where it was last context switched and it continues in member @delivery@ after the resume.
 The @delivery@ member returns the status value in @prod@'s @main@ member, where the status is printed.
+The context switch restarts the producer at the point where it was last context switched, so it continues in @delivery@ after the resume.
+@delivery@ returns the status value in @prod@'s coroutine main, where the status is printed.
 The loop then repeats calling @delivery@, where each call resumes the consumer coroutine.
 The context switch to the consumer continues in @payment@.
 The consumer increments and returns the receipt to the call in @cons@'s @main@ member.
+The consumer increments and returns the receipt to the call in @cons@'s coroutine main.
 The loop then repeats calling @payment@, where each call resumes the producer coroutine.
 …
 The context switch restarts @cons@ in @payment@ and it returns with the last receipt.
 The consumer terminates its loops because @done@ is true, its @main@ terminates, so @cons@ transitions from a coroutine back to an object, and @prod@ reactivates after the resume in @stop@.
 The @stop@ member returns and @prod@'s @main@ member terminates.
+@stop@ returns and @prod@'s coroutine main terminates.
 The program main restarts after the resume in @start@.
+The @start@ member returns and the program main terminates.
+\subsubsection{Construction}
+One important design challenge for implementing 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 expect both to have fully constructed objects once execution enters the coroutine main and to be able to resume the coroutine from the constructor.
+There are several solutions to this problem but the chosen option effectively forces the design of the coroutine.
+Furthermore, \CFA faces an extra challenge as polymorphic routines create invisible thunks when cast 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:
+\begin{cfa}
+// async: Runs function asynchronously on another thread
+forall(otype T)
+extern void async(void (*func)(T*), T* obj);
+forall(otype T)
+void noop(T*) {}
+void bar() {
+        int a;
+        async(noop, &a); // start thread running noop with argument a
+}
+\end{cfa}
+The generated C code\footnote{Code trimmed down for brevity} creates a local thunk to hold type information:
+\begin{cfa}
+extern void async(/* omitted */, void (*func)(void*), void* obj);
+void noop(/* omitted */, void* obj){}
+void bar(){
+        int a;
+        void _thunk0(int* _p0){
+                /* omitted */
+                noop(/* omitted */, _p0);
+        }
+        /* omitted */
+        async(/* omitted */, ((void (*)(void*))(&_thunk0)), (&a));
+}
+\end{cfa}
+The problem in this example is a storage management issue, the function pointer @_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 behaviour; \ie 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.
+\subsubsection{Alternative: Composition}
+One solution to this challenge is to use composition/containment, where coroutine fields are added to manage the coroutine.
+\begin{cfa}
+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{cfa}
+The downside of this approach is that users need to correctly construct the coroutine handle before using it.
+Like any other objects, the user must carefully choose construction order to prevent usage of objects not yet constructed.
+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.
+\subsubsection{Alternative: Reserved keyword}
+The next alternative is to use language support to annotate coroutines as follows:
+\begin{cfa}
+coroutine Fibonacci {
+        int fn; // used for communication
+};
+\end{cfa}
+The @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 wanting 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.
+\subsubsection{Alternative: Lambda Objects}
+@start@ returns and the program main terminates.
+\subsection{Coroutine Implementation}
+A significant implementation challenge for coroutines (and threads, see section \ref{threads}) is adding extra fields and executing code after/before the coroutine constructor/destructor and coroutine main to create/initialize/de-initialize/destroy extra fields and the stack.
+There are several solutions to this problem and the chosen option forced the \CFA coroutine design.
+Object-oriented inheritance provides extra fields and code in a restricted context, but it requires programmers to explicitly perform the inheritance:
+\begin{cfa}
+struct mycoroutine $\textbf{\textsf{inherits}}$ baseCoroutine { ... }
+\end{cfa}
+and the programming language (and possibly its tool set, \eg debugger) may need to understand @baseCoroutine@ because of the stack.
+Furthermore, the execution of constructs/destructors is in the wrong order for certain operations, \eg for threads;
+\eg, if the thread is implicitly started, it must start \emph{after} all constructors, because the thread relies on a completely initialized object, but the inherited constructor runs \emph{before} the derived.
+An alternatively is composition:
+\begin{cfa}
+struct mycoroutine {
+        ... // declarations
+        baseCoroutine dummy; // composition, last declaration
+}
+\end{cfa}
+which also requires an explicit declaration that must be the last one to ensure correct initialization order.
+However, there is nothing preventing wrong placement or multiple declarations.
 For coroutines as for threads, many implementations are based on routine pointers or function objects~\cite{Butenhof97, C++14, MS:VisualC++, BoostCoroutines15}.
 For example, Boost implements coroutines in terms of four functor object types:
+For example, Boost implements coroutines in terms of four functor object-types:
 \begin{cfa}
 asymmetric_coroutine<>::pull_type
 …
 symmetric_coroutine<>::yield_type
 \end{cfa}
+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 a simple function pointer in the same way @pthread@ does for threads:
+\begin{cfa}
+void foo( coroutine_t cid, void* arg ) {
+        int* value = (int*)arg;
+Similarly, the canonical threading paradigm is often based on function pointers, \eg @pthread@~\cite{pthreads}, \Csharp~\cite{Csharp}, Go~\cite{Go}, and Scala~\cite{Scala}.
+However, the generic thread-handle (identifier) is limited (few operations), unless it is wrapped in a custom type.
+\begin{cfa}
+void mycor( coroutine_t cid, void * arg ) {
+        int * value = (int *)arg;                               $\C{// type unsafe, pointer-size only}$
         // Coroutine body
+}
 int main() {
+        int value = 0;
+        coroutine_t cid = coroutine_create( &foo, (void*)&value );
+        coroutine_resume( &cid );
+}
+\end{cfa}
+This semantics is more common for thread interfaces but coroutines work equally well.
+As discussed in section \ref{threads}, this approach is superseded by static approaches in terms of expressivity.
+\subsubsection{Alternative: Trait-Based Coroutines}
+Finally, the underlying approach, which is the one closest to \CFA idioms, is to use trait-based lazy coroutines.
+This approach defines a coroutine as anything that satisfies the trait @is_coroutine@ (as defined below) and is used as a coroutine.
+\begin{cfa}
+trait is_coroutine(dtype T) {
+      void main(T& this);
+      coroutine_desc* get_coroutine(T& this);
+        int input = 0, output;
+        coroutine_t cid = coroutine_create( &mycor, (void *)&input ); $\C{// type unsafe, pointer-size only}$
+        coroutine_resume( cid, (void *)input, (void **)&output ); $\C{// type unsafe, pointer-size only}$
+}
+\end{cfa}
+Since the custom type is simple to write in \CFA and solves several issues, added support for routine/lambda-based coroutines adds very little.
+The selected approach is to use language support by introducing a new kind of aggregate (structure):
+\begin{cfa}
+coroutine Fibonacci {
+        int fn; // communication variables
 };
+forall( dtype T | is_coroutine(T) ) void suspend(T&);
+forall( dtype T | is_coroutine(T) ) void resume (T&);
+\end{cfa}
+This ensures that an object is not a coroutine until @resume@ is called on the object.
+Correspondingly, any object that is passed to @resume@ is a coroutine since it must satisfy the @is_coroutine@ trait to compile.
+\end{cfa}
+The @coroutine@ keyword means the compiler (and tool set) can find and inject code where needed.
+The downside of this approach is that it makes coroutine a special case in the language.
+Users wanting 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 a programming language.
+While this is ultimately the option used for idiomatic \CFA code, coroutines and threads can still be constructed without using the language support.
+The reserved keyword eases use for the common cases.
+Part of the mechanism to generalize coroutines is using a \CFA trait, which defines a coroutine as anything satisfying the trait @is_coroutine@, and this trait is used to restrict coroutine-manipulation functions:
+\begin{cfa}
+trait is_coroutine( dtype T ) {
+      void main( T & this );
+      coroutine_desc * get_coroutine( T & this );
+};
+forall( dtype T | is_coroutine(T) ) void get_coroutine( T & );
+forall( dtype T | is_coroutine(T) ) void suspend( T & );
+forall( dtype T | is_coroutine(T) ) void resume( T & );
+\end{cfa}
+This definition ensures there is a statically-typed @main@ function that is the starting point (first stack frame) of a coroutine.
+No return value or additional parameters are necessary for this function, because the coroutine type allows an arbitrary number of interface functions with corresponding arbitrary typed input/output values.
+As well, any object passed to @suspend@ and @resume@ is a coroutine since it must satisfy the @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 @get_coroutine@ routine.
 The \CFA keyword @coroutine@ simply has the effect of implementing the getter and forward declarations required for users to implement the main routine.
 \begin{center}
 \begin{tabular}{c c c}
+\begin{cfa}[tabsize=3]
+coroutine MyCoroutine {
+        int someValue;
+The \CFA keyword @coroutine@ implicitly implements the getter and forward declarations required for implementing the coroutine main:
+\begin{cquote}
+\begin{tabular}{@{}ccc@{}}
+\begin{cfa}
+coroutine MyCor {
+        int value;
 };
+\end{cfa} & == & \begin{cfa}[tabsize=3]
+struct MyCoroutine {
+        int someValue;
+        coroutine_desc __cor;
+\end{cfa}
+& {\Large $\Rightarrow$} &
+\begin{tabular}{@{}ccc@{}}
+\begin{cfa}
+struct MyCor {
+        int value;
+        coroutine_desc cor;
 };
+static inline
+coroutine_desc* get_coroutine(
+        struct MyCoroutine& this
+) {
+        return &this.__cor;
+}
+void main(struct MyCoroutine* this);
+\end{cfa}
+&
+\begin{cfa}
+static inline coroutine_desc *
+get_coroutine( MyCor & this ) {
+        return &this.cor;
+}
+\end{cfa}
+&
+\begin{cfa}
+void main( MyCor * this );
 \end{cfa}
 \end{tabular}
+\end{center}
+The combination of these two approaches allows users new to coroutining and concurrency to have an easy and concise specification, while more advanced users have tighter control on memory layout and initialization.
+\subsection{Thread Interface}\label{threads}
+The basic building blocks of multithreading in \CFA are \textbf{cfathread}.
+Both user and kernel threads are supported, where user threads are the concurrency mechanism and kernel threads are the parallel mechanism.
+User threads offer a flexible and lightweight interface.
+A thread can be declared using a struct declaration @thread@ as follows:
+\begin{cfa}
+thread foo {};
+\end{cfa}
+As for coroutines, the keyword is a thin wrapper around a \CFA trait:
+\begin{cfa}
+trait is_thread(dtype T) {
+      void ^?{}(T & mutex this);
+      void main(T & this);
+      thread_desc* get_thread(T & this);
+\end{tabular}
+\end{cquote}
+The combination of these two approaches allows an easy and concise specification to coroutining (and concurrency) for normal users, while more advanced users have tighter control on memory layout and initialization.
+\subsection{Thread Interface}
+\label{threads}
+Both user and kernel threads are supported, where user threads provide concurrency and kernel threads provide parallelism.
+Like coroutines and for the same design reasons, the selected approach for user threads is to use language support by introducing a new kind of aggregate (structure) and a \CFA trait:
+\begin{cquote}
+\begin{tabular}{@{}c@{\hspace{2\parindentlnth}}c@{}}
+\begin{cfa}
+thread myThread {
+        // communication variables
 };
+\end{cfa}
+Obviously, for this thread implementation to be useful 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 @main@ routine to a thread supersedes this approach.
+Since the @main@ routine is already a special routine in \CFA (where the program begins), it is a natural extension of the semantics to use overloading to declare mains for different threads (the normal main being the main of the initial thread).
+\end{cfa}
+&
+\begin{cfa}
+trait is_thread( dtype T ) {
+      void main( T & this );
+      thread_desc * get_thread( T & this );
+      void ^?{}( T & `mutex` this );
+};
+\end{cfa}
+\end{tabular}
+\end{cquote}
+(The qualifier @mutex@ for the destructor parameter is discussed in Section~\ref{s:Monitors}.)
+Like a coroutine, the statically-typed @main@ function is the starting point (first stack frame) of a user thread.
+The difference is that a coroutine borrows a thread from its caller, so the first thread resuming a coroutine creates an instance of @main@;
+whereas, a user thread receives its own thread from the runtime system, which starts in @main@ as some point after the thread constructor is run.\footnote{
+The \lstinline@main@ function is already a special routine in C (where the program begins), so it is a natural extension of the semantics to use overloading to declare mains for different coroutines/threads (the normal main being the main of the initial thread).}
+No return value or additional parameters are necessary for this function, because the task type allows an arbitrary number of interface functions with corresponding arbitrary typed input/output values.
+\begin{comment} % put in appendix with coroutine version ???
 As such the @main@ routine of a thread can be defined as
 \begin{cfa}
 …
+}
 \end{cfa}
 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 \textbf{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 \textbf{api} such as @fork@ and @join@ is relatively common in the literature, such an interface is unnecessary.
 Indeed, the simplest approach is to use \textbf{raii} principles and have threads @fork@ after the constructor has completed and @join@ before the destructor runs.
+\begin{cfa}
+thread World;
 void main(World & this) {
+\end{comment}
+For user threads to be useful, it must be possible to start and stop the underlying thread, and wait for it to complete execution.
+While using an API such as @fork@ and @join@ is relatively common, such an interface is awkward and unnecessary.
+A simple approach is to use allocation/deallocation principles, and have threads implicitly @fork@ after construction and @join@ before destruction.
+\begin{cfa}
+thread World {};
+void main( World & this ) {
         sout | "World!" | endl;
+}
+void main() {
+        World w;
+        // Thread forks here
+        // Printing "Hello " and "World!" are run concurrently
+        sout | "Hello " | endl;
+        // Implicit join at end of scope
+}
+\end{cfa}
+This semantic has several advantages over explicit semantics: a thread is always started and stopped exactly once, users cannot make any programming errors, and it naturally scales to multiple threads meaning basic synchronization is very simple.
+\begin{cfa}
+thread MyThread {
+        //...
+int main() {
+        World w`[10]`;                                                  $\C{// implicit forks after creation}$
+        sout | "Hello " | endl;                                 $\C{// "Hello " and 10 "World!" printed concurrently}$
+}                                                                                       $\C{// implicit joins before destruction}$
+\end{cfa}
+This semantics ensures a thread is started and stopped exactly once, eliminating some programming error, and scales to multiple threads for basic (termination) synchronization.
+This tree-structure (lattice) create/delete from C block-structure is generalized 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{cfa}
+int main() {
+        MyThread * heapLived;
+        {
+                MyThread blockLived;                            $\C{// fork block-based thread}$
+                heapLived = `new`( MyThread );          $\C{// fork heap-based thread}$
+                ...
+        }                                                                               $\C{// join block-based thread}$
+        ...
+        `delete`( heapLived );                                  $\C{// join heap-based thread}$
+}
+\end{cfa}
+The heap-based approach allows arbitrary thread-creation topologies, with respect to fork/join-style concurrency.
+Figure~\ref{s:ConcurrentMatrixSummation} shows concurrently adding the rows of a matrix and then totalling the subtotals sequential, after all the row threads have terminated.
+The program uses heap-based threads because each thread needs different constructor values.
+(Python provides a simple iteration mechanism to initialize array elements to different values allowing stack allocation.)
+The allocation/deallocation pattern appears unusual because allocated objects are immediately deleted without any intervening code.
+However, for threads, the deletion provides implicit synchronization, which is the intervening code.
+While the subtotals are added in linear order rather than completion order, which slight inhibits concurrency, the computation is restricted by the critical-path thread (\ie the thread that takes the longest), and so any inhibited concurrency is very small as totalling the subtotals is trivial.
+\begin{figure}
+\begin{cfa}
+thread Adder {
+    int * row, cols, & subtotal;                        $\C{// communication}$
 };
+// main
+void main(MyThread& this) {
+        //...
+}
+void foo() {
+        MyThread thrds[10];
+        // Start 10 threads at the beginning of the scope
+        DoStuff();
+        // Wait for the 10 threads to finish
+}
+\end{cfa}
+However, one of the drawbacks of this approach is that threads always form a tree where nodes must always outlive their children, \ie they are always destroyed in the opposite order of construction because of C scoping rules.
+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{cfa}
+thread MyThread {
+        //...
+};
+void main(MyThread& this) {
+        //...
+}
+void foo() {
+        MyThread* long_lived;
+        {
+                // Start a thread at the beginning of the scope
+                MyThread short_lived;
+                // 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 long_lived to finish
+        delete long_lived;
+}
+\end{cfa}
+% ======================================================================
+% ======================================================================
+\section{Concurrency}
+% ======================================================================
+% ======================================================================
+Several tools 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 (\ie message passing versus routine calls).
+This distinction in turn means that, in order to be effective, programmers need to learn two sets of design patterns.
+void ?{}( Adder & adder, int row[], int cols, int & subtotal ) {
+    adder.[ row, cols, &subtotal ] = [ row, cols, &subtotal ];
+}
+void main( Adder & adder ) with( adder ) {
+    subtotal = 0;
+    for ( int c = 0; c < cols; c += 1 ) {
+                subtotal += row[c];
+    }
+}
+int main() {
+    const int rows = 10, cols = 1000;
+    int matrix[rows][cols], subtotals[rows], total = 0;
+    // read matrix
+    Adder * adders[rows];
+    for ( int r = 0; r < rows; r += 1 ) {       $\C{// start threads to sum rows}$
+                adders[r] = new( matrix[r], cols, &subtotals[r] );
+    }
+    for ( int r = 0; r < rows; r += 1 ) {       $\C{// wait for threads to finish}$
+                delete( adders[r] );                            $\C{// termination join}$
+                total += subtotals[r];                          $\C{// total subtotal}$
+    }
+    sout | total | endl;
+}
+\end{cfa}
+\caption{Concurrent Matrix Summation}
+\label{s:ConcurrentMatrixSummation}
+\end{figure}
+\section{Synchronization / Mutual Exclusion}
+Uncontrolled non-deterministic execution is meaningless.
+To reestablish meaningful execution requires mechanisms to reintroduce determinism (control non-determinism), called synchronization and mutual exclusion, where synchronization is a timing relationship among threads and mutual exclusion is an access-control mechanism on data shared by threads.
+Since many deterministic challenges appear with the use of mutable shared state, some languages/libraries disallow it (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka~\cite{Akka} (Scala)).
+In these paradigms, interaction among concurrent objects is performed by stateless message-passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms closely relate to networking concepts (\eg channels~\cite{CSP,Go}).
+However, in call/return-based languages, these approaches force a clear distinction (\ie introduce a new programming paradigm) between non-concurrent and concurrent computation (\ie function call versus message passing).
+This distinction means a programmers needs to learn two sets of design patterns.
 While this distinction can be hidden away in library code, effective use of the library 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 desirable to have a higher-level construct be the core concurrency paradigm~\cite{Hochstein05}.
+An approach that is worth mentioning because it is gaining in popularity is transactional memory~\cite{Herlihy93}.
+While this approach is even pursued by system languages like \CC~\cite{Cpp-Transactions}, the performance and feature set is currently too restrictive to be the main concurrency paradigm for system languages, 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}.
+In contrast, approaches based on statefull models more closely resemble the standard call/return programming-model, resulting in a single programming paradigm.
+At the lowest level, concurrent control is implemented as atomic operations, upon which different kinds of locks mechanism are constructed, \eg semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}.
+However, for productivity it is always desirable to use the highest-level construct that provides the necessary efficiency~\cite{Hochstein05}.
+A newer approach is transactional memory~\cite{Herlihy93}.
+While this approach is pursued in hardware~\cite{Nakaike15} and system languages, like \CC~\cite{Cpp-Transactions}, the performance and feature set is still too restrictive to be the main concurrency paradigm for system languages, 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 mutual exclusion 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---\eg 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.
+Many programming languages -- \eg 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.
+\subsection{Basics}
+Non-determinism requires concurrent systems to offer support for mutual-exclusion and synchronization.
+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.
+\subsubsection{Mutual-Exclusion}
+As mentioned above, mutual-exclusion is the guarantee that only a fix number of threads can enter a critical section at once.
+For these reasons, this project proposes monitors as the core concurrency construct, upon which even higher-level approaches can be easily constructed..
+\subsection{Mutual Exclusion}
+A group of instructions manipulating a specific instance of shared data that must be performed atomically is called an (individual) \newterm{critical-section}~\cite{Dijkstra65}.
+A generalization is a \newterm{group critical-section}~\cite{Joung00}, where multiple tasks with the same session may use the resource simultaneously, but different sessions may not use the resource simultaneously.
+The readers/writer problem~\cite{Courtois71} is an instance of a group critical-section, where readers have the same session and all writers have a unique session.
+\newterm{Mutual exclusion} enforces the correction number of threads are using a critical section at the same time.
 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 concurrency techniques, which sacrifice some performance in order to improve ease of use.
 Ease of use comes by either guaranteeing some problems cannot occur (\eg being deadlock free) or by offering a more explicit coupling between data and corresponding critical section.
+Methods range from low-level locks, which are fast and flexible but require significant attention for correctness, to higher-level concurrency techniques, which sacrifice some performance to improve ease of use.
+Ease of use comes by either guaranteeing some problems cannot occur (\eg deadlock free), or by offering a more explicit coupling between shared data and critical section.
 For example, the \CC @std::atomic<T>@ offers an easy way to express mutual-exclusion on a restricted set of operations (\eg reading/writing large types atomically).
 Another challenge with low-level locks is composability.
 Locks have restricted composability because it takes careful organizing for multiple locks to be used while preventing deadlocks.
+Easing composability is another feature higher-level mutual-exclusion mechanisms often offer.
+\subsubsection{Synchronization}
 As with mutual-exclusion, low-level synchronization primitives often offer good performance and good flexibility at the cost of ease of use.
 Again, higher-level mechanisms often simplify usage by adding either better coupling between synchronization and data (\eg message passing) or offering a simpler solution to otherwise involved challenges.
+However, a significant challenge with (low-level) locks is composability because it takes careful organization for multiple locks to be used while preventing deadlock.
+Easing composability is another feature higher-level mutual-exclusion mechanisms offer.
+\subsection{Synchronization}
+Synchronization enforces relative ordering of execution, and synchronization tools provide numerous mechanisms to establish these timing relationships.
+Low-level synchronization primitives offer good performance and flexibility at the cost of ease of use.
+Higher-level mechanisms often simplify usage by adding better coupling between synchronization and data (\eg message passing), or offering a simpler solution to otherwise involved challenges, \eg barrier lock.
 As mentioned above, synchronization can be expressed as guaranteeing that event \textit{X} always happens before \textit{Y}.
+Most of the time, synchronization 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 is called \textbf{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 example is the thread that finishes using a resource and unblocks a thread waiting to use the resource, but the unblocked thread must compete to acquire the resource.
+Often synchronization is used to order access to a critical section, \eg ensuring the next kind of thread to enter a critical section is a reader thread
+If a writer thread is scheduled for next access, but another reader thread acquires the critical section first, the reader has \newterm{barged}.
+Barging can result in staleness/freshness problems, where a reader barges ahead of a write and reads temporally stale data, or a writer barges ahead of another writer overwriting data with a fresh value preventing the previous value from having an opportunity to be read.
 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 flag variables to detect barging threads are said to be using barging avoidance, while algorithms that baton-pass locks~\cite{Andrews89} between threads instead of releasing the locks are said to be using barging prevention.
+% ======================================================================
+% ======================================================================
+This challenge is often split into two different approaches, barging avoidance and barging prevention.
+Algorithms that allow a barger but divert it until later are avoiding the barger, while algorithms that preclude a barger from entering during synchronization in the critical section prevent the barger completely.
+baton-pass locks~\cite{Andrews89} between threads instead of releasing the locks are said to be using barging prevention.
 \section{Monitors}
+% ======================================================================
+% ======================================================================
+\label{s:Monitors}
 A \textbf{monitor} is a set of routines that ensure mutual-exclusion when accessing shared state.
 More precisely, a monitor is a programming technique that associates mutual-exclusion to routine scopes, as opposed to mutex locks, where mutual-exclusion is defined by lock/release calls independently of any scoping of the calling routine.
 …
 Given these building blocks, it is possible to reproduce all three of the popular paradigms.
 Indeed, \textbf{uthread} is the default paradigm in \CFA.
 However, disabling \textbf{preemption} on the \textbf{cfacluster} means \textbf{cfathread} effectively become \textbf{fiber}.
+However, disabling \textbf{preemption} on a cluster means threads effectively become fibers.
 Since several \textbf{cfacluster} with different scheduling policy can coexist in the same application, this allows \textbf{fiber} and \textbf{uthread} to coexist in the runtime of an application.
 Finally, it is possible to build executors for thread pools from \textbf{uthread} or \textbf{fiber}, which includes specialized jobs like actors~\cite{Actors}.

doc/papers/general/Paper.tex

-              r3ef35bd
+              reba74ba
 Nevertheless, C, first standardized almost forty years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
 \CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining both source and runtime compatibility with C and a familiar programming model for programmers.
+\CFA (pronounced ``C-for-all'', and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language-features to C, while maintaining source and runtime compatibility in the familiar C programming model.
 The four key design goals for \CFA~\cite{Bilson03} are:
 (1) The behaviour of standard C code must remain the same when translated by a \CFA compiler as when translated by a C compiler;
 …
 Starting with a translator versus a compiler makes it easier and faster to generate and debug C object-code rather than intermediate, assembler or machine code.
 The translator design is based on the \emph{visitor pattern}, allowing multiple passes over the abstract code-tree, which works well for incrementally adding new feature through additional visitor passes.
 At the heart of the translator is the type resolver, which handles the polymorphic routine/type overload-resolution.
+At the heart of the translator is the type resolver, which handles the polymorphic function/type overload-resolution.
 % @plg2[8]% cd cfa-cc/src; cloc libcfa
 % -------------------------------------------------------------------------------
 …
 Finally, it is impossible to describe a programming language without usages before definitions.
 Therefore, syntax and semantics appear before explanations;
 hence, patience is necessary until details are presented.
+Therefore, syntax and semantics appear before explanations, and related work (Section~\ref{s:RelatedWork}) is deferred until \CFA is presented;
+hence, patience is necessary until details are discussed.
 …
 \end{quote}
 \vspace{-9pt}
 C already has a limited form of ad-hoc polymorphism in the form of its basic arithmetic operators, which apply to a variety of different types using identical syntax.
+C already has a limited form of ad-hoc polymorphism in its basic arithmetic operators, which apply to a variety of different types using identical syntax.
 \CFA extends the built-in operator overloading by allowing users to define overloads for any function, not just operators, and even any variable;
 Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C.
 …
+}
 \end{cfa}
 Since @pair( T *, T * )@ is a concrete type, there are no implicit parameters passed to @lexcmp@, so the generated code is identical to a function written in standard C using @void *@, yet the \CFA version is type-checked to ensure the fields of both pairs and the arguments to the comparison function match in type.
+Since @pair( T *, T * )@ is a concrete type, there are no implicit parameters passed to @lexcmp@, so the generated code is identical to a function written in standard C using @void *@, yet the \CFA version is type-checked to ensure the members of both pairs and the arguments to the comparison function match in type.
 Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \newterm{tag-structures}.
 …
 \subsection{Member Access}
 It is also possible to access multiple fields from a single expression using a \newterm{member-access}.
+It is also possible to access multiple members from a single expression using a \newterm{member-access}.
 The result is a single tuple-valued expression whose type is the tuple of the types of the members, \eg:
 \begin{cfa}
 …
 \begin{cfa}
 forall( dtype T0, dtype T1 | sized(T0) | sized(T1) ) struct _tuple2 {
         T0 field_0;  T1 field_1;                                        $\C{// generated before the first 2-tuple}$
+        T0 member_0;  T1 member_1;                                      $\C{// generated before the first 2-tuple}$
 };
 _tuple2(int, int) f() {
         _tuple2(double, double) x;
         forall( dtype T0, dtype T1, dtype T2 | sized(T0) | sized(T1) | sized(T2) ) struct _tuple3 {
                 T0 field_0;  T1 field_1;  T2 field_2;   $\C{// generated before the first 3-tuple}$
+                T0 member_0;  T1 member_1;  T2 member_2;        $\C{// generated before the first 3-tuple}$
         };
         _tuple3(int, double, int) y;
 …
 \begin{comment}
 Since tuples are essentially structures, tuple indexing expressions are just field accesses:
+Since tuples are essentially structures, tuple indexing expressions are just member accesses:
 \begin{cfa}
 void f(int, [double, char]);
 …
 _tuple2(int, double) x;
 x.field_0+x.field_1;
 printf("%d %g\n", x.field_0, x.field_1);
 f(x.field_0, (_tuple2){ x.field_1, 'z' });
 \end{cfa}
 Note that due to flattening, @x@ used in the argument position is converted into the list of its fields.
+x.member_0+x.member_1;
+printf("%d %g\n", x.member_0, x.member_1);
+f(x.member_0, (_tuple2){ x.member_1, 'z' });
+\end{cfa}
+Note that due to flattening, @x@ used in the argument position is converted into the list of its members.
 In the call to @f@, the second and third argument components are structured into a tuple argument.
 Similarly, tuple member expressions are recursively expanded into a list of member access expressions.
 …
 The various kinds of tuple assignment, constructors, and destructors generate GNU C statement expressions.
 A variable is generated to store the value produced by a statement expression, since its fields may need to be constructed with a non-trivial constructor and it may need to be referred to multiple time, \eg in a unique expression.
+A variable is generated to store the value produced by a statement expression, since its members may need to be constructed with a non-trivial constructor and it may need to be referred to multiple time, \eg in a unique expression.
 The use of statement expressions allows the translator to arbitrarily generate additional temporary variables as needed, but binds the implementation to a non-standard extension of the C language.
 However, there are other places where the \CFA translator makes use of GNU C extensions, such as its use of nested functions, so this restriction is not new.
 …
 Heterogeneous data is often aggregated into a structure/union.
 To reduce syntactic noise, \CFA provides a @with@ statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate field-qualification by opening a scope containing the field identifiers.
+To reduce syntactic noise, \CFA provides a @with@ statement (see Pascal~\cite[\S~4.F]{Pascal}) to elide aggregate member-qualification by opening a scope containing the member identifiers.
 \begin{cquote}
 \vspace*{-\baselineskip}%???
 …
 The type must be an aggregate type.
 (Enumerations are already opened.)
 The object is the implicit qualifier for the open structure-fields.
+The object is the implicit qualifier for the open structure-members.
 All expressions in the expression list are open in parallel within the compound statement, which is different from Pascal, which nests the openings from left to right.
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
 struct S { int `i`; int j; double m; } s, w;
+The difference between parallel and nesting occurs for members with the same name and type:
+\begin{cfa}
+struct S { int `i`; int j; double m; } s, w;    $\C{// member i has same type in structure types S and T}$
 struct T { int `i`; int k; int m; } t, w;
 with ( s, t ) {
+with ( s, t ) {                                                         $\C{// open structure variables s and t in parallel}$
         j + k;                                                                  $\C{// unambiguous, s.j + t.k}$
         m = 5.0;                                                                $\C{// unambiguous, s.m = 5.0}$
 …
 For parallel semantics, both @s.i@ and @t.i@ are visible, so @i@ is ambiguous without qualification;
 for nested semantics, @t.i@ hides @s.i@, so @i@ implies @t.i@.
 \CFA's ability to overload variables means fields with the same name but different types are automatically disambiguated, eliminating most qualification when opening multiple aggregates.
+\CFA's ability to overload variables means members with the same name but different types are automatically disambiguated, eliminating most qualification when opening multiple aggregates.
 Qualification or a cast is used to disambiguate.
 …
 \begin{cfa}
 void ?{}( S & s, int i ) with ( s ) {           $\C{// constructor}$
         `s.i = i;`  j = 3;  m = 5.5;                    $\C{// initialize fields}$
+        `s.i = i;`  j = 3;  m = 5.5;                    $\C{// initialize members}$
+}
 \end{cfa}
 …
 \lstMakeShortInline@%
 \end{cquote}
 The only exception is bit field specification, which always appear to the right of the base type.
+The only exception is bit-field specification, which always appear to the right of the base type.
 % Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a function parameter.
 However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
 …
 // pointer to array of 5 doubles
 // common bit field syntax
+// common bit-field syntax
 …
 \subsection{Type Nesting}
 Nested types provide a mechanism to organize associated types and refactor a subset of fields into a named aggregate (\eg sub-aggregates @name@, @address@, @department@, within aggregate @employe@).
+Nested types provide a mechanism to organize associated types and refactor a subset of members into a named aggregate (\eg sub-aggregates @name@, @address@, @department@, within aggregate @employe@).
 Java nested types are dynamic (apply to objects), \CC are static (apply to the \lstinline[language=C++]@class@), and C hoists (refactors) nested types into the enclosing scope, meaning there is no need for type qualification.
 Since \CFA in not object-oriented, adopting dynamic scoping does not make sense;
 instead \CFA adopts \CC static nesting, using the field-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@'' (see Figure~\ref{f:TypeNestingQualification}).
+instead \CFA adopts \CC static nesting, using the member-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@'' (see Figure~\ref{f:TypeNestingQualification}).
 \begin{figure}
 \centering
 …
 Destruction parameters are useful for specifying storage-management actions, such as de-initialize but not deallocate.}.
 \begin{cfa}
 struct VLA { int len, * data; };                        $\C{// variable length array of integers}$
 void ?{}( VLA & vla ) with ( vla ) { len = 10;  data = alloc( len ); }  $\C{// default constructor}$
+struct VLA { int size, * data; };                       $\C{// variable length array of integers}$
+void ?{}( VLA & vla ) with ( vla ) { size = 10;  data = alloc( size ); }  $\C{// default constructor}$
 void ^?{}( VLA & vla ) with ( vla ) { free( data ); } $\C{// destructor}$
+{
 …
 \end{cfa}
 @VLA@ is a \newterm{managed type}\footnote{
 A managed type affects the runtime environment versus a self-contained type.}: a type requiring a non-trivial constructor or destructor, or with a field of a managed type.
+A managed type affects the runtime environment versus a self-contained type.}: a type requiring a non-trivial constructor or destructor, or with a member of a managed type.
 A managed type is implicitly constructed at allocation and destructed at deallocation to ensure proper interaction with runtime resources, in this case, the @data@ array in the heap.
 For details of the code-generation placement of implicit constructor and destructor calls among complex executable statements see~\cite[\S~2.2]{Schluntz17}.
 …
 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}:
 \begin{cfa}
 void ?{}( VLA & vla, int size, char fill ) with ( vla ) {  $\C{// initialization}$
         len = size;  data = alloc( len, fill );
+void ?{}( VLA & vla, int size, char fill = '\0' ) {  $\C{// initialization}$
+        vla.[ size, data ] = [ size, alloc( size, fill ) ];
+}
 void ?{}( VLA & vla, VLA other ) {                      $\C{// copy, shallow}$
         vla.len = other.len;  vla.data = other.data;
+        vla = other;
+}
 \end{cfa}
 …
 \CFA constructors may be explicitly called, like Java, and destructors may be explicitly called, like \CC.
 Explicit calls to constructors double as a \CC-style \emph{placement syntax}, useful for construction of member fields in user-defined constructors and reuse of existing storage allocations.
+Explicit calls to constructors double as a \CC-style \emph{placement syntax}, useful for construction of members in user-defined constructors and reuse of existing storage allocations.
 Like the other operators in \CFA, there is a concise syntax for constructor/destructor function calls:
 \begin{cfa}
 …
         y{ x };                                                                 $\C{// reallocate y, points to x}$
         x{};                                                                    $\C{// reallocate x, not pointing to y}$
+        //  ^z{};  ^y{};  ^x{};
+}
+}       //  ^z{};  ^y{};  ^x{};
 \end{cfa}
 …
 For compatibility with C, a copy constructor from the first union member type is also defined.
 For @struct@ types, each of the four functions are implicitly defined to call their corresponding functions on each member of the struct.
 To better simulate the behaviour of C initializers, a set of \newterm{field constructors} is also generated for structures.
+To better simulate the behaviour of C initializers, a set of \newterm{member constructors} is also generated for structures.
 A constructor is generated for each non-empty prefix of a structure's member-list to copy-construct the members passed as parameters and default-construct the remaining members.
 To allow users to limit the set of constructors available for a type, when a user declares any constructor or destructor, the corresponding generated function and all field constructors for that type are hidden from expression resolution;
+To allow users to limit the set of constructors available for a type, when a user declares any constructor or destructor, the corresponding generated function and all member constructors for that type are hidden from expression resolution;
 similarly, the generated default constructor is hidden upon declaration of any constructor.
 These semantics closely mirror the rule for implicit declaration of constructors in \CC\cite[p.~186]{ANSI98:C++}.
 …
 \section{Related Work}
+\label{s:RelatedWork}
 …
 C provides variadic functions through @va_list@ objects, but the programmer is responsible for managing the number of arguments and their types, so the mechanism is type unsafe.
 KW-C~\cite{Buhr94a}, a predecessor of \CFA, introduced tuples to C as an extension of the C syntax, taking much of its inspiration from SETL.
 The main contributions of that work were adding MRVF, tuple mass and multiple assignment, and record-field access.
+The main contributions of that work were adding MRVF, tuple mass and multiple assignment, and record-member access.
 \CCeleven introduced @std::tuple@ as a library variadic template structure.
 Tuples are a generalization of @std::pair@, in that they allow for arbitrary length, fixed-size aggregation of heterogeneous values.

src/CodeGen/CodeGenerator.cc

-              r3ef35bd
+              reba74ba
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {
+                if ( pretty ) return decl->get_name();
+                if ( decl->get_mangleName() != "" ) {
+                // GCC builtins should always be printed unmangled
+                if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name;
+                if ( decl->mangleName != "" ) {
                         // need to incorporate scope level in order to differentiate names for destructors
                         return decl->get_scopedMangleName();
                 } else {
                         return decl->get_name();
+                        return decl->name;
                 } // if
+        }

src/Common/Heap.cc

-              r3ef35bd
+              reba74ba
 #include <iostream>
 //#define WITH_HEAP_STATISTICS
+#define WITH_HEAP_STATISTICS
 namespace HeapStats {
 …
 #else
         struct StatBlock {
+                const char * name = nullptr;
+                size_t mallocs    = 0;
+                size_t frees      = 0;
+                const char * name  = nullptr;   ///< Name of this pass
+                size_t mallocs     = 0;                 ///< Allocations in this pass
+                size_t frees       = 0;                 ///< Frees in this pass
+                size_t n_allocs    = 0;                 ///< Current number of live allocations
+                size_t peak_allocs = 0;                 ///< Peak number of live allocations this pass
         };
         StatBlock    passes[100] = {{ "Pre-Parse", 0, 0 }};
+        StatBlock    passes[100] = {{ "Pre-Parse", 0, 0, 0, 0 }};
         const size_t passes_size = sizeof(passes) / sizeof(passes[0]);
         size_t       passes_cnt = 1;
 …
                 passes[passes_cnt].mallocs = 0;
                 passes[passes_cnt].frees   = 0;
+                passes[passes_cnt].n_allocs
+                        = passes[passes_cnt].peak_allocs
+                        = passes[passes_cnt-1].n_allocs;
                 passes_cnt++;
 …
+        }
         void print(const StatBlock& stat, size_t nc, size_t total_mallocs, size_t total_frees) {
+        void print(const StatBlock& stat, size_t nc, size_t total_mallocs, size_t total_frees, size_t overall_peak) {
                 std::cerr << std::setw(nc) << stat.name;
                 std::cerr << " | ";
+                print(stat.mallocs, total_mallocs);
+                print(stat.frees  , total_frees  );
+                print(stat.mallocs,     total_mallocs);
+                print(stat.frees,       total_frees  );
+                print(stat.peak_allocs, overall_peak );
                 std::cerr << "\n";
+        }
 …
                 size_t total_mallocs = 0;
                 size_t total_frees   = 0;
+                size_t overall_peak  = 0;
                 for(size_t i = 0; i < passes_cnt; i++) {
                         nc = std::max(nc, std::strlen(passes[i].name));
                         total_mallocs += passes[i].mallocs;
                         total_frees   += passes[i].frees;
+                }
+                size_t nct = nc + 44;
+                        overall_peak = std::max(overall_peak, passes[i].peak_allocs);
+                }
+                size_t nct = nc + 65;
                 const char * const title = "Heap Usage Statistic";
 …
                 print('-', nct);
                 std::cerr << std::setw(nc) << "Pass";
                 std::cerr << " |       Malloc Count |         Free Count |" << std::endl;
+                std::cerr << " |       Malloc Count |         Free Count |        Peak Allocs |" << std::endl;
                 print('-', nct);
                 for(size_t i = 0; i < passes_cnt; i++) {
                         print(passes[i], nc, total_mallocs, total_frees);
+                        print(passes[i], nc, total_mallocs, total_frees, overall_peak);
+                }
                 print('-', nct);
+                print({"Sum", total_mallocs, total_frees}, nc, total_mallocs, total_frees);
+                print({"Sum", total_mallocs, total_frees, 0, overall_peak},
+                        nc, total_mallocs, total_frees, overall_peak);
+        }
 …
                 void * malloc( size_t size ) {
                         static auto __malloc = reinterpret_cast<void * (*)(size_t)>(interpose_symbol( "malloc", nullptr ));
+                        if( passes_cnt > 0 ) passes[passes_cnt - 1].mallocs++;
+                        if( passes_cnt > 0 ) {
+                                passes[passes_cnt - 1].mallocs++;
+                                passes[passes_cnt - 1].n_allocs++;
+                                passes[passes_cnt - 1].peak_allocs
+                                        = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs);
+                        }
                         return __malloc( size );
+                }
 …
                 void free( void * ptr ) {
                         static auto __free = reinterpret_cast<void   (*)(void *)>(interpose_symbol( "free", nullptr ));
+                        if( passes_cnt > 0 ) passes[passes_cnt - 1].frees++;
+                        if( passes_cnt > 0 ) {
+                                passes[passes_cnt - 1].frees++;
+                                passes[passes_cnt - 1].n_allocs--;
+                        }
                         return __free( ptr );
+                }
 …
                 void * calloc( size_t nelem, size_t size ) {
                         static auto __calloc = reinterpret_cast<void * (*)(size_t, size_t)>(interpose_symbol( "calloc", nullptr ));
+                        if( passes_cnt > 0 ) passes[passes_cnt - 1].mallocs++;
+                        if( passes_cnt > 0 ) {
+                                passes[passes_cnt - 1].mallocs++;
+                                passes[passes_cnt - 1].n_allocs++;
+                                passes[passes_cnt - 1].peak_allocs
+                                        = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs);
+                        }
                         return __calloc( nelem, size );
+                }

src/Common/ScopedMap.h

-              r3ef35bd
+              reba74ba
 // Created On       : Wed Dec 2 11:37:00 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:18:24 2017
 // Update Count     : 2
+// Last Modified On : Mon May 21 15:22:40 2018
+// Update Count     : 3
 //
 …
+        }
+        template< typename value_t >
+        std::pair< iterator, bool > insertAt( size_type scope, const Key& key, value_t&& value ) {
+                return insertAt( scope, std::make_pair( key, std::forward<value_t>( value ) ) );
+        }
         Value& operator[] ( const Key &key ) {
                 iterator slot = find( key );

src/GenPoly/GenPoly.cc

-              r3ef35bd
+              reba74ba
                         return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
                                 || typesPolyCompatible( ap->get_base(), bp->get_base() );
+                } else if ( aid == type_index{typeid(ReferenceType)} ) {
+                        ReferenceType *ap = as<ReferenceType>(a), *bp = as<ReferenceType>(b);
+                        return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
+                                || typesPolyCompatible( ap->get_base(), bp->get_base() );
                 } else if ( aid == type_index{typeid(ArrayType)} ) {
                         ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);

src/GenPoly/Lvalue.cc

-              r3ef35bd
+              reba74ba
                         if ( isIntrinsicReference( appExpr ) ) {
                                 // eliminate reference types from intrinsic applications - now they return lvalues
                                 Type * result = appExpr->result;
                                 appExpr->result = result->stripReferences()->clone();
+                                ReferenceType * result = strict_dynamic_cast< ReferenceType * >( appExpr->result );
+                                appExpr->result = result->base->clone();
                                 appExpr->result->set_lvalue( true );
                                 if ( ! inIntrinsic ) {
 …
                 void FixIntrinsicResult::premutate( FunctionDecl * funcDecl ) {
                         GuardValue( inIntrinsic );
                         inIntrinsic =  funcDecl->linkage == LinkageSpec::Intrinsic;
+                        inIntrinsic = funcDecl->linkage == LinkageSpec::Intrinsic;
+                }
 …
                                         ret = new AddressExpr( ret );
+                                }
                                 if ( srcType->get_lvalue() && srcType->get_qualifiers() != strict_dynamic_cast<ReferenceType *>( destType )->base->get_qualifiers() ) {
+                                if ( srcType->get_lvalue() && ! ResolvExpr::typesCompatible( srcType, strict_dynamic_cast<ReferenceType *>( destType )->base, SymTab::Indexer() ) ) {
                                         // must keep cast if cast-to type is different from the actual type
                                         castExpr->arg = ret;

src/Parser/DeclarationNode.cc

-              r3ef35bd
+              reba74ba
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 16 09:37:17 2018
 // Update Count     : 1070
+// Last Modified On : Tue May 22 08:39:29 2018
+// Update Count     : 1074
 //
 …
 #include "SynTree/Type.h"          // for Type, Type::StorageClasses, Type::...
 #include "TypeData.h"              // for TypeData, TypeData::Aggregate_t
 #include "TypedefTable.h"          // for TypedefTable, TypedefTable::kind_t...
+#include "TypedefTable.h"          // for TypedefTable
 class Initializer;
 …
 DeclarationNode::DeclarationNode() :
+                builtin( NoBuiltinType ),
                 type( nullptr ),
                 bitfieldWidth( nullptr ),
 …
         newnode->name = name ? new string( *name ) : nullptr;
+        newnode->builtin = NoBuiltinType;
         newnode->type = maybeClone( type );
         newnode->storageClasses = storageClasses;
 …
         newnode->type->function.body = body;
-        // ignore unnamed routine declarations: void p( int (*)(int) );
-        if ( newnode->name ) {
-                typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
-        } // if
         if ( ret ) {
                 newnode->type->base = ret->type;
 …
         newnode->name = name;
         newnode->enumeratorValue.reset( constant );
-        typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
         return newnode;
 } // DeclarationNode::newEnumConstant
 …
                                         type->aggregate.params = q->type->forall; // make polymorphic type
                                         // change implicit typedef from TYPEDEFname to TYPEGENname
                                         typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
+                                        typedefTable.changeKind( *type->aggregate.name, TYPEGENname );
                                 } // if
                         } else {                                                                        // not polymorphic

src/Parser/LinkageSpec.h

-              r3ef35bd
+              reba74ba
                 Overrideable = 1 << 2,
                 Builtin = 1 << 3,
+                GccBuiltin = 1 << 4,
                 NoOfSpecs = 1 << 4,
+                NoOfSpecs = 1 << 5,
         };
 …
                         bool is_overridable : 1;
                         bool is_builtin : 1;
+                        bool is_gcc_builtin : 1;
                 };
                 constexpr Spec( unsigned int val ) : val( val ) {}
 …
         inline bool isOverridable( Spec spec ) { return spec.is_overridable; }
         inline bool isBuiltin( Spec spec ) { return spec.is_builtin; }
+        inline bool isGccBuiltin( Spec spec ) { return spec.is_gcc_builtin; }
         // Pre-defined flag combinations:
 …
         constexpr Spec const AutoGen = { Mangle | Generate | Overrideable };
         // gcc internal
         constexpr Spec const Compiler = { Builtin };
+        constexpr Spec const Compiler = { Mangle | Builtin | GccBuiltin };
         // mangled builtins
         constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin };

src/Parser/TypedefTable.cc

-              r3ef35bd
+              reba74ba
 // TypedefTable.cc --
 //
 // Author           : Rodolfo G. Esteves
+// Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug 15 18:24:42 2016
 // Update Count     : 25
+// Last Modified On : Tue May 22 08:40:01 2018
+// Update Count     : 121
 //
-#include <ext/alloc_traits.h>    // for __alloc_traits<>::value_type
-#include <cassert>               // for assert
-#include <list>                  // for list, _List_iterator, list<>::iterator
-#include <map>                   // for _Rb_tree_iterator, _Rb_tree_const_it...
-#include <memory>                // for allocator_traits<>::value_type
-#include <utility>               // for pair
-#include "Parser/ParserTypes.h"  // for typedefTable
-#include "Parser/parser.hh"      // for IDENTIFIER
 #include "TypedefTable.h"
+using namespace std;
+#include <cassert>                                                                              // for assert
 #if 0
 #include <iostream>
 #define debugPrint( x ) cerr << x
 #else
 …
 #endif
+TypedefTable::TypedefTable() : currentScope( 0 ) {}
+using namespace std;                                                                    // string, iostream
+bool TypedefTable::exists( const string &identifier ) {
+        return table.count( identifier ) > 0;
+}
+TypedefTable::~TypedefTable() {
+        if ( ! SemanticErrorThrow && kindTable.currentScope() != 0 ) {
+                // std::cerr << "scope failure " << kindTable.currentScope() << endl;
+        } // if
+} // TypedefTable::~TypedefTable
+int TypedefTable::isKind( const string &identifier ) const {
+        tableType::const_iterator id_pos = table.find( identifier );
+bool TypedefTable::exists( const string & identifier ) {
+        return kindTable.find( identifier ) != kindTable.end();
+} // TypedefTable::exists
+int TypedefTable::isKind( const string & identifier ) const {
+        KindTable::const_iterator posn = kindTable.find( identifier );
         // Name lookup defaults to identifier, and then the identifier's kind is set by the parser.
         if ( id_pos == table.end() ) return IDENTIFIER;
         return id_pos->second.begin()->kind;
+}
+        if ( posn == kindTable.end() ) return IDENTIFIER;
+        return posn->second;
+} // TypedefTable::isKind
+void TypedefTable::changeKind( const string &identifier, kind_t kind ) {
+        tableType::iterator id_pos = table.find( identifier );
+        if ( id_pos == table.end() ) return;
+        id_pos->second.begin()->kind = kind;
+}
+void TypedefTable::changeKind( const string & identifier, int kind ) {
+        KindTable::iterator posn = kindTable.find( identifier );
+        if ( posn != kindTable.end() ) posn->second = kind;     // exists => update
+} // TypedefTable::changeKind
 // SKULLDUGGERY: Generate a typedef for the aggregate name so the aggregate does not have to be qualified by
 // "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed
 // if the name is explicitly used.
 void TypedefTable::makeTypedef( const string &name ) {
+// "struct". Only generate the typedef, if the name is not in use. The typedef is implicitly (silently) removed if the
+// name is explicitly used.
+void TypedefTable::makeTypedef( const string & name ) {
         if ( ! typedefTable.exists( name ) ) {
                 typedefTable.addToEnclosingScope( name, TypedefTable::TD );
+                typedefTable.addToEnclosingScope( name, TYPEDEFname );
         } // if
+}
+} // TypedefTable::makeTypedef
+void TypedefTable::addToScope( const std::string &identifier, kind_t kind, int scope ) {
+        if ( currentTrait != "" && scope == contextScope ) {
+                DeferredEntry entry = { identifier, kind };
+                contexts[currentTrait].push_back( entry );
+        } else {
+                debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << " from scope " << currentScope << endl );
+                Entry newEntry = { scope, kind };
+                tableType::iterator curPos = table.find( identifier );
+                if ( curPos == table.end()) {
+                        list< Entry > newList;
+                        newList.push_front( newEntry );
+                        table[identifier] = newList;
+                } else {
+                        list< Entry >::iterator listPos = (*curPos ).second.begin();
+                        while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
+                                listPos++;
+                        } // while
+                        (*curPos ).second.insert( listPos, newEntry );
+                } // if
+        } // if
+}
+void TypedefTable::addToCurrentScope( const std::string &identifier, kind_t kind ) {
+        addToScope( identifier, kind, currentScope );
+}
+void TypedefTable::addToCurrentScope( kind_t kind ) {
+        addToCurrentScope( nextIdentifiers.top(), kind );
+}
+void TypedefTable::addToEnclosingScope( const std::string &identifier, kind_t kind ) {
+        assert( currentScope >= 1 );
+        addToScope( identifier, kind, currentScope - 1 );
+}
+void TypedefTable::addToEnclosingScope( kind_t kind ) {
+        addToEnclosingScope( nextIdentifiers.top(), kind );
+}
+void TypedefTable::addToEnclosingScope2( const std::string &identifier, kind_t kind ) {
+        assert( currentScope >= 2 );
+        addToScope( identifier, kind, currentScope - 2 );
+}
+void TypedefTable::addToEnclosingScope2( kind_t kind ) {
+        addToEnclosingScope2( nextIdentifiers.top(), kind );
+}
+void TypedefTable::setNextIdentifier( const std::string &identifier ) {
+        nextIdentifiers.top() = identifier;
+}
+void TypedefTable::openTrait( const std::string &contextName ) {
+        map< string, deferListType >::iterator i = contexts.find( contextName );
+        if ( i != contexts.end() ) {
+                deferListType &entries = i->second;
+                for ( deferListType::iterator i = entries.begin(); i != entries.end(); i++) {
+                        addToEnclosingScope( i->identifier, i->kind );
+                } // for
+        } // if
+}
+void TypedefTable::addToEnclosingScope( const std::string & identifier, int kind ) {
+        assert( kindTable.currentScope() >= 1 );
+        auto scope = kindTable.currentScope() - 1;
+        debugPrint( "Adding " << identifier << " as kind " << kind << " scope " << scope << endl );
+        auto ret = kindTable.insertAt( scope, identifier, kind );
+        if ( ! ret.second ) ret.first->second = kind;           // exists => update
+} // TypedefTable::addToEnclosingScope
 void TypedefTable::enterScope() {
+        currentScope += 1;
+        deferListStack.push( deferListType() );
+        nextIdentifiers.push( "" );
+        debugPrint( "Entering scope " << currentScope << ", nextIdentifiers size is " << nextIdentifiers.size() << endl );
+}
+        kindTable.beginScope();
+        debugPrint( "Entering scope " << kindTable.currentScope() << endl );
+} // TypedefTable::enterScope
 void TypedefTable::leaveScope() {
+        debugPrint( "Leaving scope " << currentScope << endl );
+        for ( tableType::iterator i = table.begin(); i != table.end(); ) {
+                list< Entry > &declList = (*i).second;
+                while ( ! declList.empty() && declList.front().scope == currentScope ) {
+                        declList.pop_front();
+                }
+                if ( declList.empty() ) {                                               // standard idom for erasing during traversal
+                        table.erase( i++ );
+                } else
+                        ++i;
+        } // for
+        currentScope -= 1;
+        for ( deferListType::iterator i = deferListStack.top().begin(); i != deferListStack.top().end(); i++ ) {
+                addToCurrentScope( i->identifier, i->kind );
+        } // for
+        deferListStack.pop();
+        debugPrint( "nextIdentifiers size is " << nextIdentifiers.size() << " top is " << nextIdentifiers.top() << endl );
+        nextIdentifiers.pop();
+}
+        debugPrint( "Leaving scope " << kindTable.currentScope() << endl );
+        kindTable.endScope();
+} // TypedefTable::leaveScope
+void TypedefTable::enterTrait( const std::string &contextName ) {
+        currentTrait = contextName;
+        contextScope = currentScope;
+}
+void TypedefTable::leaveTrait() {
+        currentTrait = "";
+}
+void TypedefTable::print( void ) const {
+        for ( tableType::const_iterator i = table.begin(); i != table.end(); i++) {
+                debugPrint( (*i ).first << ": " );
+                list< Entry > declList = (*i).second;
+                for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
+                        debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
+                }
+                debugPrint( endl );
+        } // for
+}
+// void TypedefTable::print( void ) const {
+//      for ( KindTable::const_iterator i = table.begin(); i != table.end(); i++) {
+//              debugPrint( (*i ).first << ": " );
+//              list< Entry > declList = (*i).second;
+//              for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
+//                      debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
+//              }
+//              debugPrint( endl );
+//      } // for
+// }
 // Local Variables: //

src/Parser/TypedefTable.h

-              r3ef35bd
+              reba74ba
 // TypedefTable.h --
 //
 // Author           : Rodolfo G. Esteves
+// Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:33:14 2017
 // Update Count     : 34
+// Last Modified On : Tue May 22 08:39:29 2018
+// Update Count     : 77
 //
 #pragma once
+#include <list>       // for list
+#include <map>        // for map, map<>::value_compare
+#include <stack>      // for stack
+#include <string>     // for string
+#include <string>                                                                               // for string
+#include "Common/ScopedMap.h"                                                   // for ScopedMap
 #include "ParserTypes.h"
 #include "parser.hh"  // for IDENTIFIER, TYPEDEFname, TYPEGENname
+#include "parser.hh"                                                                    // for IDENTIFIER, TYPEDEFname, TYPEGENname
 class TypedefTable {
+        typedef ScopedMap< std::string, int > KindTable;
+        KindTable kindTable;
   public:
+        enum kind_t { ID = IDENTIFIER, TD = TYPEDEFname, TG = TYPEGENname };
+  private:
+        struct Entry {
+                int scope;
+                kind_t kind;
+        };
+        ~TypedefTable();
+        struct DeferredEntry {
+                std::string identifier;
+                kind_t kind;
+        };
+        typedef std::map< std::string, std::list< Entry > > tableType;
+        tableType table;
+        int currentScope;
+        std::string currentTrait;
+        int contextScope;
+        typedef std::list< DeferredEntry > deferListType;
+        std::stack< deferListType > deferListStack;
+        std::map< std::string, deferListType > contexts;
+        std::stack< std::string > nextIdentifiers;
+        void addToScope( const std::string &identifier, kind_t kind, int scope );
+  public:
+        TypedefTable();
+        bool exists( const std::string &identifier );
+        int isKind( const std::string &identifier ) const;
+        void changeKind( const std::string &identifier, kind_t kind );
+        void makeTypedef( const std::string &name );
+        // "addToCurrentScope" adds the identifier/type pair to the current scope. This does less than you think it does,
+        // since each declaration is within its own scope.  Mostly useful for type parameters.
+        void addToCurrentScope( const std::string &identifier, kind_t kind );
+        void addToCurrentScope( kind_t kind );                  // use nextIdentifiers.top()
+        // "addToEnclosingScope" adds the identifier/type pair to the scope that encloses the current one.  This is the
+        // right way to handle type and typedef names
+        void addToEnclosingScope( const std::string &identifier, kind_t kind );
+        void addToEnclosingScope( kind_t kind );                // use nextIdentifiers.top()
+        // "addToEnclosingScope2" adds the identifier/type pair to the scope that encloses the scope enclosing the the
+        // current one.  This is the right way to handle assertion names
+        void addToEnclosingScope2( const std::string &identifier, kind_t kind );
+        void addToEnclosingScope2( kind_t kind );               // use nextIdentifiers.top()
+        // set the next identifier to be used by an "add" operation without an identifier parameter within the current scope
+        void setNextIdentifier( const std::string &identifier );
+        // dump the definitions from a pre-defined context into the current scope
+        void openTrait( const std::string &contextName );
+        bool exists( const std::string & identifier );
+        int isKind( const std::string & identifier ) const;
+        void changeKind( const std::string & identifier, int kind );
+        void makeTypedef( const std::string & name );
+        void addToEnclosingScope( const std::string & identifier, int kind );
         void enterScope();
         void leaveScope();
+        void enterTrait( const std::string &contextName );
+        void leaveTrait();
+        void print() const;
+};
+}; // TypedefTable
 // Local Variables: //

src/Parser/parser.yy

-              r3ef35bd
+              reba74ba
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri May 11 17:51:38 2018
 // Update Count     : 3261
+// Last Modified On : Thu May 24 18:11:59 2018
+// Update Count     : 3369
 //
 …
 // Does the forall bind to the struct or the routine, and how would it be possible to explicitly specify the binding.
 //   forall( otype T ) struct S { int T; } forall( otype W ) bar( W ) {}
+// Currently, the forall is associated with the routine, and the generic type has to be separately defined:
+//   forall( otype T ) struct S { int T; };
+//   forall( otype W ) bar( W ) {}
 void rebindForall( DeclarationNode * declSpec, DeclarationNode * funcDecl ) {
         if ( declSpec->type->kind == TypeData::Aggregate ) { // return is aggregate definition
+        if ( declSpec->type->kind == TypeData::Aggregate ) { // ignore aggregate definition
                 funcDecl->type->forall = declSpec->type->aggregate.params; // move forall from aggregate to function type
                 declSpec->type->aggregate.params = nullptr;
 …
 %type<decl> exception_declaration external_definition external_definition_list external_definition_list_opt
 %type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
+%type<decl> field_declaration field_declaration_list_opt field_declarator_opt field_declaring_list
 %type<en> field field_list field_name fraction_constants_opt
 …
 // initializers
 %type<in>  initializer initializer_list initializer_opt
+%type<in>  initializer initializer_list_opt initializer_opt
 // designators
 …
 // actions during the parser update this data structure when the class of identifiers change.
 //
+// Because the Cforall language is block-scoped, there is the possibility that an identifier can change its class in a
+// local scope; it must revert to its original class at the end of the block.  Since type names can be local to a
+// particular declaration, each declaration is itself a scope.  This requires distinguishing between type names that are
+// local to the current declaration scope and those that persist past the end of the declaration (i.e., names defined in
+// "typedef" or "otype" declarations).
+//
+// The non-terminals "push" and "pop" derive the empty string; their only use is to denote the opening and closing of
+// scopes.  Every push must have a matching pop, although it is regrettable the matching pairs do not always occur
+// within the same rule.  These non-terminals may appear in more contexts than strictly necessary from a semantic point
+// of view.  Unfortunately, these extra rules are necessary to prevent parsing conflicts -- the parser may not have
+// enough context and look-ahead information to decide whether a new scope is necessary, so the effect of these extra
+// rules is to open a new scope unconditionally.  As the grammar evolves, it may be neccesary to add or move around
+// "push" and "pop" nonterminals to resolve conflicts of this sort.
+// Because the Cforall language is block-scoped, an identifier can change its class in a local scope; it must revert to
+// its original class at the end of the block.  Since type names can be local to a particular declaration, each
+// declaration is itself a scope.  This requires distinguishing between type names that are local to the current
+// declaration scope and those that persist past the end of the declaration (i.e., names defined in "typedef" or "otype"
+// declarations).
+//
+// The non-terminals "push" and "pop" denote the opening and closing of scopes.  Every push must have a matching pop,
+// although it is regrettable the matching pairs do not always occur within the same rule.  These non-terminals may
+// appear in more contexts than strictly necessary from a semantic point of view.
 push:
 …
                 { $$ = new ExpressionNode( build_func( new ExpressionNode( build_postfix_name( $5 ) ), $2 ) ); }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
+                { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
+//              { $$ = nullptr; }
+        | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
+                { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; }
+//              { $$ = nullptr; }
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
+        | type_name '.' '[' field_list ']'                                      // CFA, nested type / tuple field selector
+                { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; }
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
                 { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; }
 …
 postfix_expression:
         primary_expression
         | postfix_expression '[' push assignment_expression pop ']'
+        | postfix_expression '[' assignment_expression ']'
                 // CFA, comma_expression disallowed in this context because it results in a common user error: subscripting a
                 // matrix with x[i,j] instead of x[i][j]. While this change is not backwards compatible, there seems to be
                 // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
         | postfix_expression '{' argument_expression_list '}' // CFA, constructor call
+                {
 …
         | postfix_expression FLOATING_FRACTIONconstant          // CFA, tuple index
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_FLOATING_FRACTIONconstant( *$2 ) ) ); }
         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
+        | postfix_expression '.' '[' field_list ']'                     // CFA, tuple field selector
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
+                {
 …
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
         | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
+        | postfix_expression ARROW '[' field_list ']'           // CFA, tuple field selector
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
         | postfix_expression DECR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
         | '(' type_no_function ')' '{' initializer_list comma_opt '}' // C99, compound-literal
+        | '(' type_no_function ')' '{' initializer_list_opt comma_opt '}' // C99, compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, new InitializerNode( $5, true ) ) ); }
         | '(' type_no_function ')' '@' '{' initializer_list comma_opt '}' // CFA, explicit C compound-literal
+        | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list '}' // CFA
 …
         | FLOATING_DECIMALconstant field
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
         | FLOATING_DECIMALconstant '[' push field_list pop ']'
                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
+        | FLOATING_DECIMALconstant '[' field_list ']'
+                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_FLOATING_DECIMALconstant( *$1 ) ), build_tuple( $3 ) ) ); }
         | field_name '.' field
                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
         | field_name '.' '[' push field_list pop ']'
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
+        | field_name '.' '[' field_list ']'
+                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | field_name ARROW field
                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
         | field_name ARROW '[' push field_list pop ']'
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
+        | field_name ARROW '[' field_list ']'
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $4 ) ) ); }
+        ;
 …
         | unary_expression assignment_operator assignment_expression
                 { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
         | unary_expression '=' '{' initializer_list comma_opt '}'
+        | unary_expression '=' '{' initializer_list_opt comma_opt '}'
                 { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
         labeled_statement
         | compound_statement
         | expression_statement                                          { $$ = $1; }
+        | expression_statement
         | selection_statement
         | iteration_statement
 …
         | RETURN comma_expression_opt ';'
                 { $$ = new StatementNode( build_return( $2 ) ); }
         | RETURN '{' initializer_list comma_opt '}'
+        | RETURN '{' initializer_list_opt comma_opt '}'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
         | THROW assignment_expression_opt ';'                           // handles rethrow
 …
 handler_predicate_opt:
         //empty
+        // empty
                 { $$ = nullptr; }
         | ';' conditional_expression                            { $$ = $2; }
 …
         type_specifier_nobody
         | type_specifier_nobody declarator
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $2->addType( $1 );
+                }
+                { $$ = $2->addType( $1 ); }
         | type_specifier_nobody variable_abstract_declarator
                 { $$ = $2->addType( $1 ); }
         | cfa_abstract_declarator_tuple no_attr_identifier      // CFA
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $1->addName( $2 );
+                }
+                { $$ = $1->addName( $2 ); }
         | cfa_abstract_declarator_tuple                                         // CFA
+        ;
 …
 declaration_list_opt:                                                                   // used at beginning of switch statement
         pop
+        pop     // empty
                 { $$ = nullptr; }
         | declaration_list
 …
 local_label_list:                                                                               // GCC, local label
         no_attr_identifier_or_type_name                         {}
         | local_label_list ',' no_attr_identifier_or_type_name {}
+        no_attr_identifier_or_type_name
+        | local_label_list ',' no_attr_identifier_or_type_name
+        ;
 …
 cfa_variable_declaration:                                                               // CFA
         cfa_variable_specifier initializer_opt
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $1->addInitializer( $2 );
+                }
+                { $$ = $1->addInitializer( $2 ); }
         | declaration_qualifier_list cfa_variable_specifier initializer_opt
                 // declaration_qualifier_list also includes type_qualifier_list, so a semantic check is necessary to preclude
                 // them as a type_qualifier cannot appear in that context.
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $2->addQualifiers( $1 )->addInitializer( $3 );;
+                }
+                { $$ = $2->addQualifiers( $1 )->addInitializer( $3 ); }
         | cfa_variable_declaration pop ',' push identifier_or_type_name initializer_opt
+                {
+                        typedefTable.addToEnclosingScope( *$5, TypedefTable::ID );
+                        $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) );
+                }
+                { $$ = $1->appendList( $1->cloneType( $5 )->addInitializer( $6 ) ); }
+        ;
 …
                 // storage-class
         cfa_abstract_declarator_no_tuple identifier_or_type_name asm_name_opt
+                {
+                        typedefTable.setNextIdentifier( *$2 );
+                        $$ = $1->addName( $2 )->addAsmName( $3 );
+                }
+                { $$ = $1->addName( $2 )->addAsmName( $3 ); }
         | cfa_abstract_tuple identifier_or_type_name asm_name_opt
+                {
+                        typedefTable.setNextIdentifier( *$2 );
+                        $$ = $1->addName( $2 )->addAsmName( $3 );
+                }
+                { $$ = $1->addName( $2 )->addAsmName( $3 ); }
         | type_qualifier_list cfa_abstract_tuple identifier_or_type_name asm_name_opt
+                {
+                        typedefTable.setNextIdentifier( *$3 );
+                        $$ = $2->addQualifiers( $1 )->addName( $3 )->addAsmName( $4 );
+                }
+                { $$ = $2->addQualifiers( $1 )->addName( $3 )->addAsmName( $4 ); }
+        ;
 cfa_function_declaration:                                                               // CFA
         cfa_function_specifier
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $1;
+                }
+                { $$ = $1; }
         | type_qualifier_list cfa_function_specifier
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $2->addQualifiers( $1 );
+                }
+                { $$ = $2->addQualifiers( $1 ); }
         | declaration_qualifier_list cfa_function_specifier
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $2->addQualifiers( $1 );
+                }
+                { $$ = $2->addQualifiers( $1 ); }
         | declaration_qualifier_list type_qualifier_list cfa_function_specifier
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $3->addQualifiers( $1 )->addQualifiers( $2 );
+                }
+        | cfa_function_declaration pop ',' push identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
+                { $$ = $3->addQualifiers( $1 )->addQualifiers( $2 ); }
+        | cfa_function_declaration ',' identifier_or_type_name '(' cfa_parameter_type_list_opt ')'
+                {
                         // Append the return type at the start (left-hand-side) to each identifier in the list.
                         DeclarationNode * ret = new DeclarationNode;
                         ret->type = maybeClone( $1->type->base );
                         $$ = $1->appendList( DeclarationNode::newFunction( $5, ret, $8, nullptr ) );
+                        $$ = $1->appendList( DeclarationNode::newFunction( $3, ret, $5, nullptr ) );
+                }
+        ;
 …
         cfa_abstract_tuple identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
                 // To obtain LR(1 ), this rule must be factored out from function return type (see cfa_abstract_declarator).
+                {
+                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
+                }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
         | cfa_function_return identifier_or_type_name '(' push cfa_parameter_type_list_opt pop ')'
+                {
+                        $$ = DeclarationNode::newFunction( $2, $1, $5, 0 );
+                }
+                { $$ = DeclarationNode::newFunction( $2, $1, $5, 0 ); }
+        ;
 …
                 { $$ = DeclarationNode::newTuple( $3 ); }
         | '[' push cfa_parameter_list pop ',' push cfa_abstract_parameter_list pop ']'
+                // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the
+                // ']'.
+                // To obtain LR(1 ), the last cfa_abstract_parameter_list is added into this flattened rule to lookahead to the ']'.
                 { $$ = DeclarationNode::newTuple( $3->appendList( $7 ) ); }
+        ;
 …
         TYPEDEF cfa_variable_specifier
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
                         $$ = $2->addTypedef();
+                }
         | TYPEDEF cfa_function_specifier
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$2->name, TYPEDEFname );
                         $$ = $2->addTypedef();
+                }
         | cfa_typedef_declaration pop ',' push no_attr_identifier
+                {
                         typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$5, TYPEDEFname );
                         $$ = $1->appendList( $1->cloneType( $5 ) );
+                }
 …
         TYPEDEF type_specifier declarator
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
                         $$ = $3->addType( $2 )->addTypedef();
+                }
         | typedef_declaration pop ',' push declarator
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$5->name, TYPEDEFname );
                         $$ = $1->appendList( $1->cloneBaseType( $5 )->addTypedef() );
+                }
         | type_qualifier_list TYPEDEF type_specifier declarator // remaining OBSOLESCENT (see 2 )
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
                         $$ = $4->addType( $3 )->addQualifiers( $1 )->addTypedef();
+                }
         | type_specifier TYPEDEF declarator
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$3->name, TYPEDEFname );
                         $$ = $3->addType( $1 )->addTypedef();
+                }
         | type_specifier TYPEDEF type_qualifier_list declarator
+                {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$4->name, TYPEDEFname );
                         $$ = $4->addQualifiers( $1 )->addTypedef()->addType( $1 );
+                }
 …
         TYPEDEF no_attr_identifier '=' assignment_expression
+                {
                         typedefTable.addToEnclosingScope( *$2, TypedefTable::TD );
                         $$ = DeclarationNode::newName( 0 );                     // unimplemented
+                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
+                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
+                }
         | typedef_expression pop ',' push no_attr_identifier '=' assignment_expression
+                {
                         typedefTable.addToEnclosingScope( *$5, TypedefTable::TD );
                         $$ = DeclarationNode::newName( 0 );                     // unimplemented
+                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
+                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
+                }
+        ;
 …
 //       declarator asm_name_opt initializer_opt
 //              {
 //                      typedefTable.addToEnclosingScope( TypedefTable::ID );
+//                      typedefTable.addToEnclosingScope( IDENTIFIER );
 //                      $$ = ( $2->addType( $1 ))->addAsmName( $3 )->addInitializer( $4 );
 //              }
 //      | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
 //              {
 //                      typedefTable.addToEnclosingScope( TypedefTable::ID );
+//                      typedefTable.addToEnclosingScope( IDENTIFIER );
 //                      $$ = $1->appendList( $1->cloneBaseType( $4->addAsmName( $5 )->addInitializer( $6 ) ) );
 //              }
 …
 c_declaration:
         declaration_specifier declaring_list
+                {
+                        $$ = distAttr( $1, $2 );
+                }
+                { $$ = distAttr( $1, $2 ); }
         | typedef_declaration
         | typedef_expression                                                            // GCC, naming expression type
 …
                 // storage-class
         declarator asm_name_opt initializer_opt
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $1->addAsmName( $2 )->addInitializer( $3 );
+                }
+                { $$ = $1->addAsmName( $2 )->addInitializer( $3 ); }
         | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) );
+                }
+                { $$ = $1->appendList( $4->addQualifiers( $3 )->addAsmName( $5 )->addInitializer( $6 ) ); }
+        ;
 …
 forall:
+        FORALL '('
+                {
+                        typedefTable.enterScope();
+                }
+          type_parameter_list ')'                                                       // CFA
+                {
+                        typedefTable.leaveScope();
+                        $$ = DeclarationNode::newForall( $4 );
+                }
+        FORALL '(' push type_parameter_list pop ')'                                     // CFA
+                { $$ = DeclarationNode::newForall( $4 ); }
+        ;
 …
 aggregate_type:                                                                                 // struct, union
         aggregate_key attribute_list_opt '{' field_declaration_list '}'
+        aggregate_key attribute_list_opt '{' field_declaration_list_opt '}'
                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt no_attr_identifier_or_type_name
+                {
                         typedefTable.makeTypedef( *$3 );                        // create typedef
                         if ( forall ) typedefTable.changeKind( *$3, TypedefTable::TG ); // possibly update
+                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
+                }
           '{' field_declaration_list '}'
+          '{' field_declaration_list_opt '}'
                 { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list '}' // CFA
+        | aggregate_key attribute_list_opt '(' type_list ')' '{' field_declaration_list_opt '}' // CFA
                 { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
         | aggregate_type_nobody
 …
+                {
                         typedefTable.makeTypedef( *$3 );
                         if ( forall ) typedefTable.changeKind( *$3, TypedefTable::TG ); // possibly update
+                        if ( forall ) typedefTable.changeKind( *$3, TYPEGENname ); // possibly update
                         forall = false;                                                         // reset
                         $$ = DeclarationNode::newAggregate( $1, $3, nullptr, nullptr, false )->addQualifiers( $2 );
 …
+        ;
 field_declaration_list:
+field_declaration_list_opt:
         // empty
                 { $$ = nullptr; }
         | field_declaration_list field_declaration
+        | field_declaration_list_opt field_declaration
                 { $$ = $1 ? $1->appendList( $2 ) : $2; }
+        ;
 …
 field_declaring_list:
         field_declarator
         | field_declaring_list ',' attribute_list_opt field_declarator
+        field_declarator_opt
+        | field_declaring_list ',' attribute_list_opt field_declarator_opt
                 { $$ = $1->appendList( $4->addQualifiers( $3 ) ); }
+        ;
 field_declarator:
+field_declarator_opt:
         // empty
                 { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
 …
                 // No SUE declaration in parameter list.
         declaration_specifier_nobody identifier_parameter_declarator default_initialize_opt
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
+                }
+                { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
         | declaration_specifier_nobody type_parameter_redeclarator default_initialize_opt
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr );
+                }
+                { $$ = $2->addType( $1 )->addInitializer( $3 ? new InitializerNode( $3 ) : nullptr ); }
+        ;
 …
 initializer:
         assignment_expression                                           { $$ = new InitializerNode( $1 ); }
         | '{' initializer_list comma_opt '}'            { $$ = new InitializerNode( $2, true ); }
+        ;
 initializer_list:
+        | '{' initializer_list_opt comma_opt '}'        { $$ = new InitializerNode( $2, true ); }
+        ;
+initializer_list_opt:
         // empty
                 { $$ = nullptr; }
         | initializer
         | designation initializer                                       { $$ = $2->set_designators( $1 ); }
         | initializer_list ',' initializer                      { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
         | initializer_list ',' designation initializer
+        | initializer_list_opt ',' initializer          { $$ = (InitializerNode *)( $1->set_last( $3 ) ); }
+        | initializer_list_opt ',' designation initializer
                 { $$ = (InitializerNode *)( $1->set_last( $4->set_designators( $3 ) ) ); }
+        ;
 …
 type_parameter:                                                                                 // CFA
         type_class no_attr_identifier_or_type_name
                 { typedefTable.addToEnclosingScope( *$2, TypedefTable::TD ); }
+                { typedefTable.addToEnclosingScope( *$2, TYPEDEFname ); }
           type_initializer_opt assertion_list_opt
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
 …
 assertion:                                                                                              // CFA
         '|' no_attr_identifier_or_type_name '(' type_list ')'
+                {
+                        typedefTable.openTrait( *$2 );
+                        $$ = DeclarationNode::newTraitUse( $2, $4 );
+                }
+                { $$ = DeclarationNode::newTraitUse( $2, $4 ); }
         | '|' '{' push trait_declaration_list '}'
                 { $$ = $4; }
         | '|' '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}' '(' type_list ')'
                 { $$ = nullptr; }
+                { SemanticError( yylloc, "Generic data-type assertion is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
         no_attr_identifier_or_type_name
+                {
                         typedefTable.addToEnclosingScope( *$1, TypedefTable::TD );
+                        typedefTable.addToEnclosingScope( *$1, TYPEDEFname );
                         $$ = DeclarationNode::newTypeDecl( $1, 0 );
+                }
         | no_attr_identifier_or_type_name '(' push type_parameter_list pop ')'
+                {
                         typedefTable.addToEnclosingScope( *$1, TypedefTable::TG );
+                        typedefTable.addToEnclosingScope( *$1, TYPEGENname );
                         $$ = DeclarationNode::newTypeDecl( $1, $4 );
+                }
 …
 trait_specifier:                                                                                // CFA
         TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' '}'
+                {
+                        typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
+                        $$ = DeclarationNode::newTrait( $2, $5, 0 );
+                }
+        | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{'
+                {
+                        typedefTable.enterTrait( *$2 );
+                        typedefTable.enterScope();
+                }
+          trait_declaration_list '}'
+                {
+                        typedefTable.leaveTrait();
+                        typedefTable.addToEnclosingScope( *$2, TypedefTable::ID );
+                        $$ = DeclarationNode::newTrait( $2, $5, $10 );
+                }
+                { $$ = DeclarationNode::newTrait( $2, $5, 0 ); }
+        | TRAIT no_attr_identifier_or_type_name '(' push type_parameter_list pop ')' '{' push trait_declaration_list '}'
+                { $$ = DeclarationNode::newTrait( $2, $5, $10 ); }
+        ;
 …
 cfa_trait_declaring_list:                                                               // CFA
         cfa_variable_specifier
+                {
-                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
-                        $$ = $1;
+                }
         | cfa_function_specifier
+                {
-                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
-                        $$ = $1;
+                }
         | cfa_trait_declaring_list pop ',' push identifier_or_type_name
+                {
+                        typedefTable.addToEnclosingScope2( *$5, TypedefTable::ID );
+                        $$ = $1->appendList( $1->cloneType( $5 ) );
+                }
+                { $$ = $1->appendList( $1->cloneType( $5 ) ); }
+        ;
 trait_declaring_list:                                                                   // CFA
         type_specifier declarator
+                {
+                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
+                        $$ = $2->addType( $1 );
+                }
+                { $$ = $2->addType( $1 ); }
         | trait_declaring_list pop ',' push declarator
+                {
+                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
+                        $$ = $1->appendList( $1->cloneBaseType( $5 ) );
+                }
+                { $$ = $1->appendList( $1->cloneBaseType( $5 ) ); }
+        ;
 …
+                }
         | type_qualifier_list
+                {
+                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
+                }
+                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
           push '{' external_definition_list '}'                         // CFA, namespace
+                {
 …
+                }
         | declaration_qualifier_list
+                {
+                        if ( $1->type->forall ) xxx = forall = true; // remember generic type
+                }
+                { if ( $1->type->forall ) xxx = forall = true; } // remember generic type
           push '{' external_definition_list '}'                         // CFA, namespace
+                {
 …
                 // declaration must still have a type_specifier.  OBSOLESCENT (see 1)
         | function_declarator compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $1->addFunctionBody( $2 );
+                }
+                { $$ = $1->addFunctionBody( $2 ); }
         | KR_function_declarator KR_declaration_list_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 );
+                }
+                { $$ = $1->addOldDeclList( $2 )->addFunctionBody( $3 ); }
+        ;
 …
         cfa_function_declaration with_clause_opt compound_statement     // CFA
+                {
-                        typedefTable.addToEnclosingScope( TypedefTable::ID );
-                        typedefTable.leaveScope();
                         // Add the function body to the last identifier in the function definition list, i.e., foo3:
                         //   [const double] foo1(), foo2( int ), foo3( double ) { return 3.0; }
 …
+                {
                         rebindForall( $1, $2 );
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
+                }
+        | declaration_specifier variable_type_redeclarator with_clause_opt compound_statement
+                {
+                        rebindForall( $1, $2 );
                         $$ = $2->addFunctionBody( $4, $3 )->addType( $1 );
+                }
                 // handles default int return type, OBSOLESCENT (see 1)
         | type_qualifier_list function_declarator with_clause_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
+                }
+                { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
                 // handles default int return type, OBSOLESCENT (see 1)
         | declaration_qualifier_list function_declarator with_clause_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 );
+                }
+                { $$ = $2->addFunctionBody( $4, $3 )->addQualifiers( $1 ); }
                 // handles default int return type, OBSOLESCENT (see 1)
         | declaration_qualifier_list type_qualifier_list function_declarator with_clause_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 );
+                }
+                { $$ = $3->addFunctionBody( $5, $4 )->addQualifiers( $2 )->addQualifiers( $1 ); }
                 // Old-style K&R function definition, OBSOLESCENT (see 4)
 …
+                {
                         rebindForall( $1, $2 );
-                        typedefTable.addToEnclosingScope( TypedefTable::ID );
-                        typedefTable.leaveScope();
                         $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addType( $1 );
+                }
                 // handles default int return type, OBSOLESCENT (see 1)
         | type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
+                }
+                { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
                 // handles default int return type, OBSOLESCENT (see 1)
         | declaration_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 );
+                }
+                { $$ = $2->addOldDeclList( $3 )->addFunctionBody( $5, $4 )->addQualifiers( $1 ); }
                 // handles default int return type, OBSOLESCENT (see 1)
         | declaration_qualifier_list type_qualifier_list KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
+                {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 );
+                }
+                { $$ = $3->addOldDeclList( $4 )->addFunctionBody( $6, $5 )->addQualifiers( $2 )->addQualifiers( $1 ); }
+        ;
 …
 paren_identifier:
         identifier
+                {
+                        typedefTable.setNextIdentifier( *$1 );
+                        $$ = DeclarationNode::newName( $1 );
+                }
+                { $$ = DeclarationNode::newName( $1 ); }
         | '(' paren_identifier ')'                                                      // redundant parenthesis
                 { $$ = $2; }
 …
 paren_type:
         typedef
+                // hide type name in enclosing scope by variable name
+                { typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER ); }
         | '(' paren_type ')'
                 { $$ = $2; }
 …
 typedef:
         TYPEDEFname
+                {
+                        typedefTable.setNextIdentifier( *$1 );
+                        $$ = DeclarationNode::newName( $1 );
+                }
+                { $$ = DeclarationNode::newName( $1 ); }
         | TYPEGENname
+                {
+                        typedefTable.setNextIdentifier( *$1 );
+                        $$ = DeclarationNode::newName( $1 );
+                }
+                { $$ = DeclarationNode::newName( $1 ); }
+        ;

src/ResolvExpr/AlternativeFinder.cc

-              r3ef35bd
+              reba74ba
                         const ExplodedArgs& args, std::vector<ArgPack>& results, std::size_t& genStart,
                         const SymTab::Indexer& indexer, unsigned nTuples = 0 ) {
                 if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
+                if ( TupleType * tupleType = dynamic_cast<TupleType*>( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr
                         ++nTuples;
                         for ( Type* type : *tupleType ) {
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
+                                // ^^^ need to handle the case where a tuple has a default argument
                                 if ( ! instantiateArgument(
                                                 type, nullptr, args, results, genStart, indexer, nTuples ) )
 …
+                        }
                         return true;
                 } else if ( TypeInstType* ttype = Tuples::isTtype( formalType ) ) {
+                } else if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
                         // formalType is a ttype, consumes all remaining arguments
                         // xxx - mixing default arguments with variadic??
 …
                                 // consider only first exploded actual
                                 Expression* expr = expl.exprs.front();
                                 Type* actualType = expr->get_result()->clone();
+                                Type* actualType = expr->result->clone();
                                 PRINT(
 …
                 ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
                 // sum cost and accumulate actuals
                 std::list<Expression*>& args = appExpr->get_args();
+                std::list<Expression*>& args = appExpr->args;
                 Cost cost = func.cost;
                 const ArgPack* pack = &result;
 …
                 // 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() ) {
+                funcEnv.add( funcType->forall );
+                if ( targetType && ! targetType->isVoid() && ! funcType->returnVals.empty() ) {
                         // attempt to narrow based on expected target type
                         Type * returnType = funcType->get_returnVals().front()->get_type();
+                        Type * returnType = funcType->returnVals.front()->get_type();
                         if ( ! unify( returnType, targetType, funcEnv, funcNeed, funcHave, funcOpenVars,
                                         indexer ) ) {
 …
                 std::size_t genStart = 0;
                 for ( DeclarationWithType* formal : funcType->get_parameters() ) {
+                for ( DeclarationWithType* formal : funcType->parameters ) {
                         ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
                         if ( ! instantiateArgument(
                                         obj->get_type(), obj->get_init(), args, results, genStart, indexer ) )
+                                        obj->type, obj->init, args, results, genStart, indexer ) )
                                 return;
+                }
 …
         void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( untypedExpr->get_function() );
+                funcFinder.findWithAdjustment( untypedExpr->function );
                 // if there are no function alternatives, then proceeding is a waste of time.
                 if ( funcFinder.alternatives.empty() ) return;
 …
                 AlternativeFinder finder( indexer, env );
                 finder.targetType = toType;
                 finder.findWithAdjustment( castExpr->get_arg() );
+                finder.findWithAdjustment( castExpr->arg );
                 AltList candidates;
 …
                         OpenVarSet openVars;
+                        alt.env.extractOpenVars( openVars );
                         // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
                         // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
                         int discardedValues = alt.expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = alt.expr->result->size() - castExpr->result->size();
                         if ( discardedValues < 0 ) continue;
                         // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
                         // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
                         // unification run for side-effects
                         unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions,
+                        unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
                                 haveAssertions, openVars, indexer );
                         Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer,
+                        Cost thisCost = castCost( alt.expr->result, castExpr->result, indexer,
                                 alt.env );
                         PRINT(
 …
                         AlternativeFinder finder( indexer, env );
                         finder.targetType = toType;
                         finder.findWithAdjustment( initExpr->get_expr() );
+                        finder.findWithAdjustment( initExpr->expr );
                         for ( Alternative & alt : finder.get_alternatives() ) {
                                 TypeEnvironment newEnv( alt.env );
 …
                                 PRINT(
                                         std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
+                                 )
+                                )
                                 // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
                                 // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
                                 // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                                 // to.
                                 int discardedValues = alt.expr->get_result()->size() - toType->size();
+                                int discardedValues = alt.expr->result->size() - toType->size();
                                 if ( discardedValues < 0 ) continue;
                                 // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
                                 // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
                                 // unification run for side-effects
                                 unify( toType, alt.expr->get_result(), newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
                                 Cost thisCost = castCost( alt.expr->get_result(), toType, indexer, newEnv );
+                                unify( toType, alt.expr->result, newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+                                Cost thisCost = castCost( alt.expr->result, toType, indexer, newEnv );
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away

src/ResolvExpr/Resolver.cc

-              r3ef35bd
+              reba74ba
         namespace {
+                void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                struct StripCasts {
+                        Expression * postmutate( CastExpr * castExpr ) {
+                                if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
+                                        // generated cast is to the same type as its argument, so it's unnecessary -- remove it
+                                        Expression * expr = castExpr->arg;
+                                        castExpr->arg = nullptr;
+                                        std::swap( expr->env, castExpr->env );
+                                        return expr;
+                                }
+                                return castExpr;
+                        }
+                        static void strip( Expression *& expr ) {
+                                PassVisitor<StripCasts> stripper;
+                                expr = expr->acceptMutator( stripper );
+                        }
+                };
+                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
+                        env.makeSubstitution( *expr->get_env() );
+                        env.makeSubstitution( *expr->env );
+                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
+                }
 …
                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
                         if ( winners.size() == 0 ) {
+                                SemanticError( untyped, toString(
+                                        "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""),
+                                        "expression: ") );
+                                SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
                         } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for "
+                                        << kindStr << (kindStr != "" ? " " : "") << "expression\n";
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
                                 untyped->print( stream );
                                 stream << " Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
                                 SemanticError( untyped->location, stream.str() );
+                        }
 …
                         if ( findDeletedExpr( choice.expr ) ) {
                                 trace( choice.expr );
+                                SemanticError( choice.expr,
+                                        "Unique best alternative includes deleted identifier in " );
+                                SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
+                        }
                         alt = std::move( choice );
 …
         void Resolver::previsit( CaseStmt *caseStmt ) {
                 if ( caseStmt->get_condition() ) {
+                if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
 …
                         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;
+                        // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
+                        // Ideally we would perform the conversion internally here.
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                newExpr = castExpr->arg;
+                                castExpr->arg = nullptr;
+                                std::swap( newExpr->env, castExpr->env );
+                        }
+                        caseStmt->condition = newExpr;
+                }
+        }
 …
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
+                std::swap( initExpr->inferParams, newExpr->inferParams ) ;
+                // InitExpr may have inferParams in the case where the expression specializes a function pointer,
+                // and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
+                newExpr->spliceInferParams( initExpr );
                 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)

src/ResolvExpr/TypeEnvironment.h

-              r3ef35bd
+              reba74ba
         //
         // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
+        //
+        // Note: since this compares pointers for position, minor changes in the source file that affect
+        // memory layout can alter compilation time in unpredictable ways. For example, the placement
+        // of a line directive can reorder type pointers with respect to each other so that assertions
+        // are seen in different orders, causing a potentially different number of unification calls when
+        // resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering line directives
+        // alone, so it would be nice to fix this comparison so that assertions compare more consistently.
+        // I've tried to modify this to compare on mangle name instead of type as the second comparator, but
+        // this causes some assertions to never be recorded. More investigation is needed.
         struct AssertCompare {
                 bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {

src/ResolvExpr/Unify.cc

r3ef35bd	reba74ba
306	306	} else if ( isopen1 ) {
307	307	result = bindVar( var1, type2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
308		} else if ( isopen2 ) {
	308	} else if ( isopen2 ) { // TODO: swap widenMode values in call, since type positions are flipped?
309	309	result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
310	310	} else {

src/SymTab/Indexer.cc

-              r3ef35bd
+              reba74ba
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
+#include "GenPoly/GenPoly.h"
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
 …
+        }
+        bool isFunction( DeclarationWithType * decl ) {
+                return GenPoly::getFunctionType( decl->get_type() );
+        }
+        bool isObject( DeclarationWithType * decl ) {
+                return ! isFunction( decl );
+        }
+        bool isDefinition( DeclarationWithType * decl ) {
+                if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
+                        // a function is a definition if it has a body
+                        return func->statements;
+                } else {
+                        // an object is a definition if it is not marked extern.
+                        // both objects must be marked extern
+                        return ! decl->get_storageClasses().is_extern;
+                }
+        }
         bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
                 // if we're giving the same name mangling to things of different types then there is something wrong
                 assert( (dynamic_cast<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing.id ) )
                         || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing.id ) ) );
+                assert( (isObject( added ) && isObject( existing.id ) )
+                        || ( isFunction( added ) && isFunction( existing.id ) ) );
                 if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
 …
+                        }
+                        // typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
+                        // we should ignore outermost pointer qualifiers, except _Atomic?
+                        FunctionDecl * newentry = dynamic_cast< FunctionDecl * >( added );
+                        FunctionDecl * oldentry = dynamic_cast< FunctionDecl * >( existing.id );
+                        if ( newentry && oldentry ) {
+                                if ( newentry->get_statements() && oldentry->get_statements() ) {
+                        if ( isDefinition( added ) && isDefinition( existing.id ) ) {
+                                if ( isFunction( added ) ) {
                                         return handleConflicts( existing, "duplicate function definition for " );
+                                } // if
+                        } else {
+                                // two objects with the same mangled name defined in the same scope.
+                                // both objects must be marked extern or both must be intrinsic for this to be okay
+                                // xxx - perhaps it's actually if either is intrinsic then this is okay?
+                                //       might also need to be same storage class?
+                                ObjectDecl * newobj = dynamic_cast< ObjectDecl * >( added );
+                                ObjectDecl * oldobj = dynamic_cast< ObjectDecl * >( existing.id );
+                                if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) {
+                                } else {
                                         return handleConflicts( existing, "duplicate object definition for " );
                                 } // if

src/SymTab/Mangler.cc

-              r3ef35bd
+              reba74ba
                 namespace {
                         /// Mangles names to a unique C identifier
                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> {
+                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
                                 Mangler( const Mangler & ) = delete;
 …
                                 void postvisit( EnumInstType * aggregateUseType );
                                 void postvisit( TypeInstType * aggregateUseType );
+                                void postvisit( TraitInstType * inst );
                                 void postvisit( TupleType * tupleType );
                                 void postvisit( VarArgsType * varArgsType );
 …
                                 bool typeMode;                  ///< Produce a unique mangled name for a type
                                 bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
+                                bool inFunctionType = false;    ///< Include type qualifiers if false.
                                 void mangleDecl( DeclarationWithType *declaration );
 …
                         void Mangler::postvisit( PointerType * pointerType ) {
                                 printQualifiers( pointerType );
+                                mangleName << "P";
+                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
+                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << "P";
                                 maybeAccept( pointerType->base, *visitor );
+                        }
 …
                         void Mangler::postvisit( ReferenceType * refType ) {
+                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
+                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
+                                // by pretending every reference type is a function parameter.
+                                GuardValue( inFunctionType );
+                                inFunctionType = true;
                                 printQualifiers( refType );
-                                mangleName << "R";
                                 maybeAccept( refType->base, *visitor );
+                        }
 …
                                 printQualifiers( functionType );
                                 mangleName << "F";
+                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
+                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
+                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
+                                GuardValue( inFunctionType );
+                                inFunctionType = true;
                                 std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
                                 acceptAll( returnTypes, *visitor );
 …
+                        }
+                        void Mangler::postvisit( TraitInstType * inst ) {
+                                printQualifiers( inst );
+                                mangleName << "_Y" << inst->name << "_";
+                        }
                         void Mangler::postvisit( TupleType * tupleType ) {
                                 printQualifiers( tupleType );
 …
                                 // skip if not including qualifiers
                                 if ( typeMode ) return;
                                 if ( ! type->get_forall().empty() ) {
                                         std::list< std::string > assertionNames;
 …
                                         mangleName << "_";
                                 } // if
+                                if ( type->get_const() ) {
+                                        mangleName << "C";
+                                } // if
+                                if ( type->get_volatile() ) {
+                                        mangleName << "V";
+                                } // if
+                                if ( ! inFunctionType ) {
+                                        // these qualifiers do not distinguish the outermost type of a function parameter
+                                        if ( type->get_const() ) {
+                                                mangleName << "C";
+                                        } // if
+                                        if ( type->get_volatile() ) {
+                                                mangleName << "V";
+                                        } // if
+                                        // Removed due to restrict not affecting function compatibility in GCC
+                                        // if ( type->get_isRestrict() ) {
+                                        //      mangleName << "E";
+                                        // } // if
+                                        if ( type->get_atomic() ) {
+                                                mangleName << "A";
+                                        } // if
+                                }
                                 if ( type->get_mutex() ) {
                                         mangleName << "M";
                                 } // if
-                                // Removed due to restrict not affecting function compatibility in GCC
-                //              if ( type->get_isRestrict() ) {
-                //                      mangleName << "E";
-                //              } // 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 ( type->get_atomic() ) {
+                                        mangleName << "A";
+                                } // if
+                                if ( inFunctionType ) {
+                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
+                                        GuardValue( inFunctionType );
+                                        inFunctionType = false;
+                                }
+                        }
                 }       // namespace

src/SynTree/ApplicationExpr.cc

-              r3ef35bd
+              reba74ba
+}
+ParamEntry::ParamEntry( ParamEntry && other ) :
+                decl( other.decl ), actualType( other.actualType ), formalType( other.formalType ), expr( other.expr ), inferParams( std::move( other.inferParams ) ) {
+        other.actualType = nullptr;
+        other.formalType = nullptr;
+        other.expr = nullptr;
+}
+ParamEntry & ParamEntry::operator=( ParamEntry && other ) {
+        if ( &other == this ) return *this;
+        decl = other.decl;
+        actualType = other.actualType;
+        formalType = other.formalType;
+        expr = other.expr;
+        other.actualType = nullptr;
+        other.formalType = nullptr;
+        other.expr = nullptr;
+        inferParams = std::move( other.inferParams );
+        return *this;
+}
 ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
         PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );

src/SynTree/Expression.cc

-              r3ef35bd
+              reba74ba
+}
+void Expression::spliceInferParams( Expression * other ) {
+        if ( ! other ) return;
+        for ( auto p : other->inferParams ) {
+                inferParams[p.first] = std::move( p.second );
+        }
+}
 Expression::~Expression() {
         delete env;

src/SynTree/Expression.h

-              r3ef35bd
+              reba74ba
         ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
         ParamEntry( const ParamEntry & other );
+        ParamEntry( ParamEntry&& other );
         ParamEntry & operator=( const ParamEntry & other );
+        ParamEntry & operator=( ParamEntry && other );
         UniqueId decl;
 …
         InferredParams & get_inferParams() { return inferParams; }
+        // move other's inferParams to this
+        void spliceInferParams( Expression * other );
         virtual Expression * clone() const override = 0;

src/Tuples/TupleAssignment.cc

-              r3ef35bd
+              reba74ba
                                                 lhsAlt.expr = new CastExpr( lhsAlt.expr,
                                                                 new ReferenceType( Type::Qualifiers(),
                                                                         lhsAlt.expr->get_result()->clone() ) );
+                                                                        lhsAlt.expr->result->clone() ) );
+                                        }
 …
                         ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
+                                currentFinder.get_environ() };
+                                matcher->compositeEnv };
                         try {
                                 finder.findWithAdjustment(*i);
 …
         ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
                 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() ) );
+                ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->result->clone(), new SingleInit( expr->clone() ) );
                 // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
                 if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                if ( ! dynamic_cast< ReferenceType * >( expr->result ) ) {
                         ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
                         ret->init = ctorInit;
 …
                 assert( (! lhs.empty() && rhs.size() <= 1) || (lhs.empty() && rhs.empty()) );
+                // xxx - may need to split this up into multiple declarations, because potential conversion to references
+                //  probably should not reference local variable - see MultipleAssignMatcher::match
                 ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
                 for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
 …
                         std::list< ObjectDecl * > ltmp;
                         std::list< ObjectDecl * > rtmp;
+                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), [&]( ResolvExpr::Alternative & alt ){
+                                return newObject( lhsNamer, alt.expr );
+                        });
+                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), [&]( ResolvExpr::Alternative & alt ){
+                                return newObject( rhsNamer, alt.expr );
+                        });
+                        zipWith( ltmp.begin(), ltmp.end(), rtmp.begin(), rtmp.end(), back_inserter(out), [&](ObjectDecl * obj1, ObjectDecl * obj2 ) { return createFunc(spotter.fname, obj1, obj2); } );
+                        for ( auto p : group_iterate( lhs, rhs ) ) {
+                                ResolvExpr::Alternative & lhsAlt = std::get<0>(p);
+                                ResolvExpr::Alternative & rhsAlt = std::get<1>(p);
+                                // convert RHS to LHS type minus one reference -- important for the case where LHS is && and RHS is lvalue, etc.
+                                ReferenceType * lhsType = strict_dynamic_cast<ReferenceType *>( lhsAlt.expr->result );
+                                rhsAlt.expr = new CastExpr( rhsAlt.expr, lhsType->base->clone() );
+                                ObjectDecl * lobj = newObject( lhsNamer, lhsAlt.expr );
+                                ObjectDecl * robj = newObject( rhsNamer, rhsAlt.expr );
+                                out.push_back( createFunc(spotter.fname, lobj, robj) );
+                                ltmp.push_back( lobj );
+                                rtmp.push_back( robj );
+                                // resolve the cast expression so that rhsAlt return type is bound by the cast type as needed, and transfer the resulting environment
+                                ResolvExpr::AlternativeFinder finder{ spotter.currentFinder.get_indexer(), compositeEnv };
+                                finder.findWithAdjustment( rhsAlt.expr );
+                                assert( finder.get_alternatives().size() == 1 );
+                                compositeEnv = std::move( finder.get_alternatives().front().env );
+                        }
                         tmpDecls.splice( tmpDecls.end(), ltmp );
                         tmpDecls.splice( tmpDecls.end(), rtmp );

src/Tuples/TupleExpansion.cc

-              r3ef35bd
+              reba74ba
 #include "SynTree/Type.h"         // for Type, Type::Qualifiers, TupleType
 #include "SynTree/Visitor.h"      // for Visitor
+#include "Tuples.h"
 class CompoundStmt;
 …
                         Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
+                        // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
+                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
+                        aggr = new UniqueExpr( aggr );
+                        if ( Tuples::maybeImpureIgnoreUnique( memberExpr->aggregate ) ) aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
 …
         Expression * TupleIndexExpander::postmutate( TupleIndexExpr * tupleExpr ) {
                 Expression * tuple = tupleExpr->get_tuple();
+                Expression * tuple = tupleExpr->tuple;
                 assert( tuple );
+                tupleExpr->set_tuple( nullptr );
+                unsigned int idx = tupleExpr->get_index();
+                TypeSubstitution * env = tupleExpr->get_env();
+                tupleExpr->set_env( nullptr );
+                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
+                StructDecl * structDecl = type->get_baseStruct();
+                assert( structDecl->get_members().size() > idx );
+                Declaration * member = *std::next(structDecl->get_members().begin(), idx);
+                tupleExpr->tuple = nullptr;
+                unsigned int idx = tupleExpr->index;
+                TypeSubstitution * env = tupleExpr->env;
+                tupleExpr->env = nullptr;
+                delete tupleExpr;
+                if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * > ( tuple ) ) {
+                        if ( ! maybeImpureIgnoreUnique( tupleExpr ) ) {
+                                // optimization: definitely pure tuple expr => can reduce to the only relevant component.
+                                assert( tupleExpr->exprs.size() > idx );
+                                Expression *& expr = *std::next(tupleExpr->exprs.begin(), idx);
+                                Expression * ret = expr;
+                                ret->env = env;
+                                expr = nullptr; // remove from list so it can safely be deleted
+                                return ret;
+                        }
+                }
+                StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->result );
+                StructDecl * structDecl = type->baseStruct;
+                assert( structDecl->members.size() > idx );
+                Declaration * member = *std::next(structDecl->members.begin(), idx);
                 MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
                 memExpr->set_env( env );
+                memExpr->env = env;
                 return memExpr;
+        }
 …
                 // remove data from shell
+                tupleExpr->set_result( nullptr );
+                tupleExpr->get_exprs().clear();
                 tupleExpr->set_env( nullptr );

src/benchmark/Makefile.am

-              r3ef35bd
+              reba74ba
 compile-array$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/array.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-attributes$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/attributes.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-empty$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w compile/empty.c                          @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-expression$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/expression.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-io$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/io.c                                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-monitor$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/monitor.c           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-operators$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/operators.c                     @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-thread$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/thread.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/thread.c             @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-typeof$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c                               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}

src/benchmark/Makefile.in

-              r3ef35bd
+              reba74ba
 compile-array$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/array.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-attributes$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/attributes.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-empty$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c                         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w compile/empty.c                          @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-expression$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/expression.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-io$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/io.c                                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-monitor$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/monitor.c           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-operators$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/operators.c                     @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-thread$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/concurrent/thread.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/thread.c             @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 compile-typeof$(EXEEXT):
         @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c                               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/libcfa/bits/containers.h

-              r3ef35bd
+              reba74ba
+        }
         #define _next .0
         #define _prev .1
+        #define next 0
+        #define prev 1
         forall(dtype T | sized(T))
         static inline void push_front( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
                 if ( head ) {
                         __get( node )_next = head;
                         __get( node )_prev = __get( *head )_prev;
+                        __get( node ).next = head;
+                        __get( node ).prev = __get( *head ).prev;
                         // inserted node must be consistent before it is seen
                         // prevent code movement across barrier
                         asm( "" : : : "memory" );
                         __get( *head )_prev = &node;
                         T & prev = *__get( node )_prev;
                         __get( prev )_next = &node;
+                        __get( *head ).prev = &node;
+                        T & _prev = *__get( node ).prev;
+                        __get( _prev ).next = &node;
+                }
                 else {
                         __get( node )_next = &node;
                         __get( node )_prev = &node;
+                        __get( node ).next = &node;
+                        __get( node ).prev = &node;
+                }
 …
         forall(dtype T | sized(T))
         static inline void remove( __dllist(T) & this, T & node ) with( this ) {
+                verify(__get);
                 if ( &node == head ) {
                         if ( __get( *head )_next == head ) {
+                        if ( __get( *head ).next == head ) {
                                 head = NULL;
+                        }
                         else {
                                 head = __get( *head )_next;
+                                head = __get( *head ).next;
+                        }
+                }
                 __get( *__get( node )_next )_prev = __get( node )_prev;
                 __get( *__get( node )_prev )_next = __get( node )_next;
                 __get( node )_next = NULL;
                 __get( node )_prev = NULL;
+        }
         #undef _next
         #undef _prev
+                __get( *__get( node ).next ).prev = __get( node ).prev;
+                __get( *__get( node ).prev ).next = __get( node ).next;
+                __get( node ).next = NULL;
+                __get( node ).prev = NULL;
+        }
+        #undef next
+        #undef prev
 #endif

src/libcfa/bits/locks.h

-              r3ef35bd
+              reba74ba
 #endif
-#if __SIZEOF_SIZE_T__ == 8
-        #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_8( &(lock), 1 ) == 0
-        #define __lock_release( lock ) __sync_lock_release_8( &(lock) );
-#elif __SIZEOF_SIZE_T__ == 4
-        #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_4( &(lock), 1 ) == 0
-        #define __lock_release( lock ) __sync_lock_release_4( &(lock) );
-#else
-        #error unsupported architecture
-#endif
 struct __spinlock_t {
+        __ALIGN__ volatile size_t lock;
+        // Wrap in struct to prevent false sharing with debug info
+        struct {
+                // Align lock on 128-bit boundary
+                __ALIGN__ volatile _Bool lock;
+        };
         #ifdef __CFA_DEBUG__
+                // previous function to acquire the lock
                 const char * prev_name;
+                // previous thread to acquire the lock
                 void* prev_thrd;
         #endif
 …
         // Lock the spinlock, return false if already acquired
         static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
                 _Bool result = __lock_test_and_test_and_set( this.lock );
+                _Bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
                 if( result ) {
                         disable_interrupts();
 …
                 for ( unsigned int i = 1;; i += 1 ) {
                         if ( __lock_test_and_test_and_set( this.lock ) ) break;
+                        if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
                         #ifndef NOEXPBACK
                                 // exponential spin
 …
+        }
-        // // Lock the spinlock, yield if already acquired
-        // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
-        //      for ( unsigned int i = 1;; i += 1 ) {
-        //              if ( __lock_test_and_test_and_set( this.lock ) ) break;
-        //              yield( i );
-        //      }
-        //      disable_interrupts();
-        //      __cfaabi_dbg_debug_do(
-        //              this.prev_name = caller;
-        //              this.prev_thrd = this_thread;
-        //      )
-        // }
         static inline void unlock( __spinlock_t & this ) {
                 enable_interrupts_noPoll();
                 __lock_release( this.lock );
+                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
+        }
 #endif

src/libcfa/concurrency/alarm.c

-              r3ef35bd
+              reba74ba
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Apr  9 13:36:18 2018
 // Update Count     : 61
+// Last Modified On : Fri May 25 06:25:47 2018
+// Update Count     : 67
 //
 …
 void __kernel_set_timer( Duration alarm ) {
+        verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm.tv);
         setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL );
+}
 …
+}
+__cfaabi_dbg_debug_do( bool validate( alarm_list_t * this ) {
+#if !defined(NDEBUG) && (defined(__CFA_DEBUG__) || defined(__CFA_VERIFY__))
+bool validate( alarm_list_t * this ) {
         alarm_node_t ** it = &this->head;
         while( (*it) ) {
 …
         return it == this->tail;
+})
+}
+#endif
 static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {

src/libcfa/concurrency/kernel

-              r3ef35bd
+              reba74ba
         __dllist_t(struct processor) idles;
+        // List of processors
+        __spinlock_t thread_list_lock;
+        __dllist_t(struct thread_desc) threads;
         // Link lists fields
         struct {

src/libcfa/concurrency/kernel.c

-              r3ef35bd
+              reba74ba
 thread_desc * mainThread;
-struct { __dllist_t(thread_desc) list; __spinlock_t lock; } global_threads ;
 struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
 //-----------------------------------------------------------------------------
 // Global state
-// volatile thread_local bool preemption_in_progress = 0;
-// volatile thread_local bool preemption_enabled = false;
-// volatile thread_local unsigned short disable_preempt_count = 1;
 thread_local struct KernelThreadData kernelTLS = {
         NULL,
 …
         node.next = NULL;
         node.prev = NULL;
         doregister(this);
+        doregister(curr_cluster, this);
         monitors{ &self_mon_p, 1, (fptr_t)0 };
 …
         procs{ __get };
         idles{ __get };
+        threads{ __get };
         doregister(this);
 …
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
-        global_threads. list{ __get };
-        global_threads. lock{};
         global_clusters.list{ __get };
         global_clusters.lock{};
 …
         ^(mainThread){};
+        ^(global_clusters.list){};
+        ^(global_clusters.lock){};
         __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
+}
 …
         else {
                 int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
+                __cfaabi_dbg_bits_write( abort_text, len );
+        }
+}
 …
 //-----------------------------------------------------------------------------
 // Global Queues
-void doregister( thread_desc & thrd ) {
-        // lock      ( global_thread.lock );
-        // push_front( global_thread.list, thrd );
-        // unlock    ( global_thread.lock );
+}
-void unregister( thread_desc & thrd ) {
-        // lock  ( global_thread.lock );
-        // remove( global_thread.list, thrd );
-        // unlock( global_thread.lock );
+}
 void doregister( cluster     & cltr ) {
         // lock      ( global_cluster.lock );
         // push_front( global_cluster.list, cltr );
         // unlock    ( global_cluster.lock );
+        lock      ( global_clusters.lock __cfaabi_dbg_ctx2);
+        push_front( global_clusters.list, cltr );
+        unlock    ( global_clusters.lock );
+}
 void unregister( cluster     & cltr ) {
+        // lock  ( global_cluster.lock );
+        // remove( global_cluster.list, cltr );
+        // unlock( global_cluster.lock );
+}
+        lock  ( global_clusters.lock __cfaabi_dbg_ctx2);
+        remove( global_clusters.list, cltr );
+        unlock( global_clusters.lock );
+}
+void doregister( cluster * cltr, thread_desc & thrd ) {
+        lock      (cltr->thread_list_lock __cfaabi_dbg_ctx2);
+        push_front(cltr->threads, thrd);
+        unlock    (cltr->thread_list_lock);
+}
+void unregister( cluster * cltr, thread_desc & thrd ) {
+        lock  (cltr->thread_list_lock __cfaabi_dbg_ctx2);
+        remove(cltr->threads, thrd );
+        unlock(cltr->thread_list_lock);
+}
 void doregister( cluster * cltr, processor * proc ) {
         // lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
         // push_front(cltr->procs, *proc);
         // unlock    (cltr->proc_list_lock);
+        lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        push_front(cltr->procs, *proc);
+        unlock    (cltr->proc_list_lock);
+}
 void unregister( cluster * cltr, processor * proc ) {
         // lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
         // remove(cltr->procs, *proc );
         // unlock(cltr->proc_list_lock);
+        lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        remove(cltr->procs, *proc );
+        unlock(cltr->proc_list_lock);
+}

src/libcfa/concurrency/kernel_private.h

-              r3ef35bd
+              reba74ba
 void doregister( struct thread_desc & thrd );
 void unregister( struct thread_desc & thrd );
+void doregister( struct cluster & cltr );
+void unregister( struct cluster & cltr );
 void doregister( struct cluster     & cltr );
 void unregister( struct cluster     & cltr );
+void doregister( struct cluster * cltr, struct thread_desc & thrd );
+void unregister( struct cluster * cltr, struct thread_desc & thrd );
 void doregister( struct cluster * cltr, struct processor * proc );

src/libcfa/concurrency/preemption.c

-              r3ef35bd
+              reba74ba
 #include "preemption.h"
+#include <assert.h>
 extern "C" {
 …
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
+                // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
                 // Check if this is a kernel
 …
                 Duration period = node->period;
                 if( period > 0 ) {
+                        // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv );
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
 …
         // If there are still alarms pending, reset the timer
+        if( alarms->head ) { __kernel_set_timer( alarms->head->alarm - currtime ); }
+        if( alarms->head ) {
+                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%lu(%lu) resetting alarm to %lu.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
+                Duration delta = alarms->head->alarm - currtime;
+                Duration caped = max(delta, 50`us);
+                // itimerval tim  = { caped };
+                // __cfaabi_dbg_print_buffer_local( "    Values are %lu, %lu, %lu %lu.\n", delta.tv, caped.tv, tim.it_value.tv_sec, tim.it_value.tv_usec);
+                __kernel_set_timer( caped );
+        }
+}
 …
         void disable_interrupts() {
                 with( kernelTLS.preemption_state ) {
+                        enabled = false;
+                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
+                        // Set enabled flag to false
+                        // should be atomic to avoid preemption in the middle of the operation.
+                        // use memory order RELAXED since there is no inter-thread on this variable requirements
+                        __atomic_store_n(&enabled, false, __ATOMIC_RELAXED);
+                        // Signal the compiler that a fence is needed but only for signal handlers
+                        __atomic_signal_fence(__ATOMIC_ACQUIRE);
                         __attribute__((unused)) unsigned short new_val = disable_count + 1;
                         disable_count = new_val;
 …
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
                 processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
                 thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic add
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
                 with( kernelTLS.preemption_state ){
 …
                         // Check if we need to prempt the thread because an interrupt was missed
                         if( prev == 1 ) {
+                                enabled = true;
+                                static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
+                                // Set enabled flag to true
+                                // should be atomic to avoid preemption in the middle of the operation.
+                                // use memory order RELAXED since there is no inter-thread on this variable requirements
+                                __atomic_store_n(&enabled, true, __ATOMIC_RELAXED);
+                                // Signal the compiler that a fence is needed but only for signal handlers
+                                __atomic_signal_fence(__ATOMIC_RELEASE);
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
 …
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
+                        kernelTLS.preemption_state.enabled = true;
+                        static_assert(__atomic_always_lock_free(sizeof(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free");
+                        // Set enabled flag to true
+                        // should be atomic to avoid preemption in the middle of the operation.
+                        // use memory order RELAXED since there is no inter-thread on this variable requirements
+                        __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED);
+                        // Signal the compiler that a fence is needed but only for signal handlers
+                        __atomic_signal_fence(__ATOMIC_RELEASE);
+                }
+        }
 …
         if( !preemption_ready() ) { return; }
         __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", kernelTLS.this_processor, kernelTLS.this_thread );
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", kernelTLS.this_processor, kernelTLS.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
         // Sync flag : prevent recursive calls to the signal handler
         kernelTLS.preemption_state.in_progress = true;
+        // We are about to CtxSwitch out of the signal handler, let other handlers in
+        signal_unblock( SIGUSR1 );
+        // Clear sighandler mask before context switching.
+        static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
+        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), NULL ) == -1 ) {
+                abort( "internal error, sigprocmask" );
+        }
         // TODO: this should go in finish action
 …
                                 case EAGAIN :
                                 case EINTR :
+                                        {__cfaabi_dbg_print_buffer_decl( " KERNEL: Spurious wakeup %d.\n", err );}
                                         continue;
                         case EINVAL :
 …
         sigset_t oldset;
         int ret;
         ret = sigprocmask(0, NULL, &oldset);
+        ret = pthread_sigmask(0, NULL, &oldset);
         if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
         ret = sigismember(&oldset, SIGUSR1);
         if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
         if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
+        ret = sigismember(&oldset, SIGALRM);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+        if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
+        ret = sigismember(&oldset, SIGTERM);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+        if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
+}

src/libcfa/concurrency/thread.c

-              r3ef35bd
+              reba74ba
         node.next = NULL;
         node.prev = NULL;
         doregister(this);
+        doregister(curr_cluster, this);
         monitors{ &self_mon_p, 1, (fptr_t)0 };
 …
 void ^?{}(thread_desc& this) with( this ) {
         unregister(this);
+        unregister(curr_cluster, this);
         ^self_cor{};
+}

src/libcfa/time

-              r3ef35bd
+              reba74ba
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // time --
 //
+//
+// time --
+//
 // Author           : Peter A. Buhr
 // Created On       : Wed Mar 14 23:18:57 2018
 …
 // Last Modified On : Sat Apr 14 17:48:23 2018
 // Update Count     : 636
 //
+//
 #pragma once
 …
 static inline int64_t ?`w( Duration dur ) { return dur.tv / (7LL * 24LL * 60LL * 60LL * TIMEGRAN); }
+static inline Duration max( Duration lhs, Duration rhs ) { return  (lhs.tv < rhs.tv) ? rhs : lhs;}
+static inline Duration min( Duration lhs, Duration rhs ) { return !(rhs.tv < lhs.tv) ? lhs : rhs;}
 //######################### C timeval #########################

src/main.cc

r3ef35bd	reba74ba
299	299
300	300	PASS( "expandUniqueExpr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
301		~~Tuples::expandUniqueExpr( translationUnit );~~
302	301
303	302	PASS( "translateEHM" , ControlStruct::translateEHM( translationUnit ) );

src/prelude/Makefile.am

-              r3ef35bd
+              reba74ba
 # create forward declarations for gcc builtins
 gcc-builtins.cf : gcc-builtins.c prototypes.sed
         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
+        ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -r -f prototypes.sed > $@
 gcc-builtins.c : builtins.def prototypes.awk
+gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf
         ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@

src/prelude/Makefile.in

-              r3ef35bd
+              reba74ba
 # create forward declarations for gcc builtins
 gcc-builtins.cf : gcc-builtins.c prototypes.sed
         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
 gcc-builtins.c : builtins.def prototypes.awk
+        ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -r -f prototypes.sed > $@
+gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf
         ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@

src/prelude/builtins.def

-              r3ef35bd
+              reba74ba
 /* Builtin used by implementation of Cilk Plus.  Most of these are decomposed
    by the compiler but a few are implemented in libcilkrts.  */
+   by the compiler but a few are implemented in libcilkrts.  */
 #undef DEF_CILK_BUILTIN_STUB
 #define DEF_CILK_BUILTIN_STUB(ENUM, NAME) \
 …
 /* Builtin used by the implementation of libsanitizer. These
    functions are mapped to the actual implementation of the
+   functions are mapped to the actual implementation of the
    libtsan library. */
 #undef DEF_SANITIZER_BUILTIN
 …
 #define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS)  \
   DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \
                false, false, false, ATTRS, false, flag_cilkplus)
+               false, false, false, ATTRS, false, flag_cilkplus)
 /* Builtin used by the implementation of Pointer Bounds Checker.  */
 …
 DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST)
+#if 0 //Ifdefed out because we hard-coded the proper overloadings of the atomic built-ins
 /* Synchronization Primitives.  */
 #include "sync-builtins.def"
-#if 0
 /* Offloading and Multi Processing builtins.  */
 #include "omp-builtins.def"

src/prelude/prelude.cf

r3ef35bd	reba74ba
458	458	signed long long int ?=?( signed long long int &, signed long long int ), ?=?( volatile signed long long int &, signed long long int );
459	459	unsigned long long int ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int );
	460	__int128 ?=?( __int128 &, __int128 ), ?=?( volatile __int128 &, __int128 );
460	461	zero_t ?=?( zero_t &, zero_t );
461	462	one_t ?=?( one_t &, one_t );

src/prelude/prototypes.awk

-              r3ef35bd
+              reba74ba
 # file "LICENCE" distributed with Cforall.
+#
 # prototypes.awk --
+# prototypes.awk --
+#
 # Author           : Peter A. Buhr
 …
 # Last Modified On : Tue Jul  5 14:32:52 2016
 # Update Count     : 32
+#
+#
 # http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def
 …
 } # BEGIN
 /BT_FN/ {
+/BT_FN/ {
     for (i = 1; i <= NF; i++) {
       if( match($i, "BT_FN") != 0 ) {
 …
       # generate function return type as macro
       for ( t = 0; t < N; t += 1 ) {                                    # find longest match
+      for ( t = 0; t < N; t += 1 ) {                                    # find longest match
         type = types[t];
         if ( index( prototype, type ) == 1 ) {          # found match
 …
         # extras
         printf( "\n#include \"builtins.def\"\n\n" );
+        printf( "\n#include \"sync-builtins.cf\"\n\n" );
         printf( "extern const char *__PRETTY_FUNCTION__;\n" );
 } # END

src/prelude/prototypes.sed

-              r3ef35bd
+              reba74ba
 /targetm/s/.*//                         #Remove targetm declarations
 /__Unsupported/s/.*//                   #Remove Unsupported types declarations
 s/void (const char \*)0();//            #Remove void (const char \*)0();
+s/void \(const char \*\)0\(\);//        #Remove void (const char \*)0();
 s/\"//g                                         #Remove extraenous quotes in declarations
+/__builtin_/s/_ /_/g                    #Remove extraenous spaces in declarations
+/__builtin_/s/_ /_/g                    #Remove extraenous spaces in declarations
+#Fix gcc overloading
+# various sed rules for the gcc sync builtins which are overloaded
+# kept here because they generate an acceptable approximate of the correct prototypes
+#/__sync_/s/_[0-9][0-9]*\(.*\)/\(\);/g  #hack since it will accept any parameters
+#/__atomic_/s/_[0-9][0-9]*\(.*\)/\(\);/g        #hack since it will accept any parameters
+#/_16/s/void \*/__int128 \*/g
+#/_8/s/void \*/long long int \*/g
+#/_4/s/void \*/int \*/g
+#/_2/s/void \*/short \*/g
+#/_1/s/void \*/char \*/g
+#s/([a-zA-Z0-9_ ]+)\s+__sync([a-z_]+)_([0-9]+)\((.*)\);/\1 __sync\2\(\4\,...); \1 __sync\2_\3\(\4\,...);/
+#s/([a-zA-Z0-9_ ]+)\s+__atomic([a-z_]+)_([0-9]+)\((.*)\);/\1 __atomic\2\(\4\); \1 __atomic\2_\3\(\4\);/

src/tests/.expect/KRfunctions.x64.txt

-              r3ef35bd
+              reba74ba
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
 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) /* ?{} */);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1) /* ^?{} */);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
+}
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_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), (*___dst__R2sS_1)));
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
+    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
 …
     __attribute__ ((unused)) signed int ___retval_f5__i_1;
+}
 signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
+signed int (*__f6__FFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
+    __attribute__ ((unused)) signed int (*___retval_f6__Fi_i__1)(signed int __anonymous_object1);
+}
 signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
+signed int (*__f7__FFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
+    __attribute__ ((unused)) signed int (*___retval_f7__Fi_ii__1)(signed int __a__i_1, signed int __b__i_1);
+}
 signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
+}
 signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
+signed int *const __f9__FPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
+}
 signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
+signed int *(*__f10__FFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
+    __attribute__ ((unused)) signed int *(*___retval_f10__FPi_ii__1)(signed int __x__i_1, signed int __y__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 ___retval_f10__PFPi_ii__1;
+    ((void)(___retval_f10__FPi_ii__1=__x__FPi_ii__2) /* ?{} */);
+    return ___retval_f10__FPi_ii__1;
+}
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
 …
     __attribute__ ((unused)) signed int ___retval_f15__i_1;
+}
 const signed int __fred__FCi___1(){
+const signed int __fred__Fi___1(){
     __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
+    signed int *(*__x__FPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     signed int __a__i_2;
     signed int __b__i_2;
     signed int *(*_tmp_cp_ret2)(signed int __x__i_1, signed int __y__i_1);
     ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
+    ((void)(__x__FPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
     ((void)(_tmp_cp_ret2) /* ^?{} */);
     const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
+    const signed int __f1__Fi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
         __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
+    }
     const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+    const signed int __f2__Fi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
         __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
+    }

src/tests/.expect/KRfunctions.x86.txt

-              r3ef35bd
+              reba74ba
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
 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) /* ?{} */);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1) /* ^?{} */);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
+}
 static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_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), (*___dst__R2sS_1)));
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
+    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 signed int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, signed int *__c__Pi_1){
 …
     __attribute__ ((unused)) signed int ___retval_f5__i_1;
+}
 signed int (*__f6__FPFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
     __attribute__ ((unused)) signed int (*___retval_f6__PFi_i__1)(signed int __anonymous_object1);
+signed int (*__f6__FFi_i__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __anonymous_object0){
+    __attribute__ ((unused)) signed int (*___retval_f6__Fi_i__1)(signed int __anonymous_object1);
+}
 signed int (*__f7__FPFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
     __attribute__ ((unused)) signed int (*___retval_f7__PFi_ii__1)(signed int __a__i_1, signed int __b__i_1);
+signed int (*__f7__FFi_ii__iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))(signed int __a__i_1, signed int __b__i_1){
+    __attribute__ ((unused)) signed int (*___retval_f7__Fi_ii__1)(signed int __a__i_1, signed int __b__i_1);
+}
 signed int *__f8__FPi_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1){
     __attribute__ ((unused)) signed int *___retval_f8__Pi_1;
+}
 signed int *const __f9__FCPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
+signed int *const __f9__FPi_PiiPi__1(signed int *__a__Pi_1, signed int __b__i_1, signed int *__c__Pi_1){
     __attribute__ ((unused)) signed int *const ___retval_f9__CPi_1;
+}
 signed int *(*__f10__FPFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
     __attribute__ ((unused)) signed int *(*___retval_f10__PFPi_ii__1)(signed int __x__i_1, signed int __y__i_1);
+signed int *(*__f10__FFPi_ii__iPiPid__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1, double __y__d_1))(signed int __x__i_1, signed int __y__i_1){
+    __attribute__ ((unused)) signed int *(*___retval_f10__FPi_ii__1)(signed int __x__i_1, signed int __y__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 ___retval_f10__PFPi_ii__1;
+    ((void)(___retval_f10__FPi_ii__1=__x__FPi_ii__2) /* ?{} */);
+    return ___retval_f10__FPi_ii__1;
+}
 signed int (*__f11__FPA0i_iPiPi__1(signed int __a__i_1, signed int *__b__Pi_1, signed int *__c__Pi_1))[]{
 …
     __attribute__ ((unused)) signed int ___retval_f15__i_1;
+}
 const signed int __fred__FCi___1(){
+const signed int __fred__Fi___1(){
     __attribute__ ((unused)) const signed int ___retval_fred__Ci_1;
     signed int *(*__x__PFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
+    signed int *(*__x__FPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
     signed int __a__i_2;
     signed int __b__i_2;
     signed int *(*_tmp_cp_ret2)(signed int __x__i_1, signed int __y__i_1);
     ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
+    ((void)(__x__FPi_ii__2=(((void)(_tmp_cp_ret2=__f10__FFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret2)));
     ((void)(_tmp_cp_ret2) /* ^?{} */);
     const signed int __f1__FCi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
+    const signed int __f1__Fi_iPiPi__2(signed int __a__i_2, signed int *__b__Pi_2, signed int *__c__Pi_2){
         __attribute__ ((unused)) const signed int ___retval_f1__Ci_2;
+    }
     const signed int __f2__FCi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+    const signed int __f2__Fi_iii__2(signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
         __attribute__ ((unused)) const signed int ___retval_f2__Ci_2;
+    }

src/tests/.expect/attributes.x64.txt

-              r3ef35bd
+              reba74ba
 struct __attribute__ ((unused)) __anonymous0 {
 };
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 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__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
+}
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
 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_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+}
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+}
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__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), (*___dst__R13s__anonymous0_1)));
+    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     return ___ret__13s__anonymous0_1;
+}
 …
 struct __attribute__ ((unused)) Agn2 {
 };
 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
+}
 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
+}
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
+static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
+static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
+static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
+static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
+}
+static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
+static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
+}
+static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
+    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
     return ___ret__5sAgn2_1;
+}
 …
     __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
 };
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
 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, __attribute__ ((unused)) signed int __f1__i_1);
 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) 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).__f2__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__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) /* ?{} */);
+}
 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).__f6__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f1__i_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_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
+static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
+static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
+static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
+static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
+static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
+static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
+static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
+static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
+static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
+static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
+static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
+static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
+}
+static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     struct Fdl ___ret__4sFdl_1;
     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__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), (*___dst__R4sFdl_1)));
+    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
+    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
+    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
+    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
+    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
+    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
+    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
+    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
     return ___ret__4sFdl_1;
+}
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_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) /* ?{} */);
     ((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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) 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).__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_object3) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) 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) /* ?{} */);
+static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 __attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
 …
 __attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned long int )5)];
 __attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned long int )5)];
 __attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
 __attribute__ ((unused,used)) signed int __f1__Fi___1();
 __attribute__ ((unused)) signed int __f1__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_f1__i_1;
+}
 __attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
 __attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
+__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
+__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
     __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
 …
     __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
 __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);
+__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object8);
+}
 signed int __vtr__Fi___1(){
 …
     __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
+}
 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
+signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
+signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
     __attribute__ ((unused)) signed int ___retval_ipd4__i_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_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_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
+signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned long int )5)]));
+signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
+signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
+signed int __tpr7__Fi_Fi_Fi_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;
 …
         signed int __i__i_2;
     };
     inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ^?{} */);
+    }
     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
+    inline void ___constructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ?{} */);
+    }
+    inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
+    }
+    inline void ___destructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ^?{} */);
+    }
+    inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
         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), (*___dst__R13s__anonymous4_2)));
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
+        ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__13s__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){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, signed int __i__i_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     ((void)sizeof(struct __anonymous4 ));
 …
         __R__C13e__anonymous5_2,
     };
     inline void ___constructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_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) /* ?{} */);
+    }
     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){
+    inline void ___constructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
+    }
+    inline void ___constructor__F_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
+        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
+    }
+    inline void ___destructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
+    }
+    inline enum __anonymous5 ___operator_assign__F13e__anonymous5_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         enum __anonymous5 ___ret__13e__anonymous5_2;
         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
         ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
+        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)(___ret__13e__anonymous5_2=(*___dst__13e__anonymous5_2)) /* ?{} */);
         return ___ret__13e__anonymous5_2;
+    }
 …
 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));
+signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_Fi_i_Fi_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_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_Fi_i_Fi_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_object32;
 …
     __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_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, __attribute__ ((unused)) signed int __anonymous_object36);
 static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
 static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned long int )10)]);
 static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned long int )10)], __attribute__ ((unused,unused)) 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) /* ?{} */);
+static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
+static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
+static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
+static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
+static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned long int )10)]);
+static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
+static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
+    {
         signed int _index0 = 0;
         for (;(_index0<10);((void)(++_index0))) {
             ((void)((*___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) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index0)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
         signed int _index1 = 0;
         for (;(_index1<10);((void)(++_index1))) {
             ((void)((*___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) /* ^?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index1)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index1)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
+static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
         signed int _index2 = (10-1);
         for (;(_index2>=0);((void)(--_index2))) {
             ((void)((*___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){
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index2)]) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ^?{} */);
+}
+static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     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));
+    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__4sVad_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)));
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index3)]=___src__4sVad_1.__anonymous_object34[((signed long int )_index3)]));
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
     return ___ret__4sVad_1;
+}
 static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
+    {
         signed int _index4 = 0;
         for (;(_index4<10);((void)(++_index4))) {
             ((void)((*___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, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index4)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
         signed int _index5 = 0;
         for (;(_index5<10);((void)(++_index5))) {
             ((void)((*___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, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned long int )10)]){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index5)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned long int )10)]){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
         signed int _index6 = 0;
         for (;(_index6<10);((void)(++_index6))) {
             ((void)((*___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, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index6)]=__anonymous_object51[((signed long int )_index6)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned long int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
         signed int _index7 = 0;
         for (;(_index7<10);((void)(++_index7))) {
             ((void)((*___dst__R4sVad_1).__anonymous_object34[((signed long int )_index7)]=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
+        }
+    }
     ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}
+            ((void)((*___dst__4sVad_1).__anonymous_object34[((signed long int )_index7)]=__anonymous_object54[((signed long int )_index7)]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/.expect/attributes.x86.txt

-              r3ef35bd
+              reba74ba
 struct __attribute__ ((unused)) __anonymous0 {
 };
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 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__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
+}
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
 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_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+}
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+}
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__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), (*___dst__R13s__anonymous0_1)));
+    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__anonymous0_1)));
     return ___ret__13s__anonymous0_1;
+}
 …
 struct __attribute__ ((unused)) Agn2 {
 };
 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1);
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___constructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
+}
 static inline void ___constructor__F_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
 static inline void ___destructor__F_R5sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1){
+}
 static inline struct Agn2 ___operator_assign__F5sAgn2_R5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__R5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
+static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
+static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1);
+static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
+static inline void ___constructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
+}
+static inline void ___constructor__F_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
+static inline void ___destructor__F_5sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1){
+}
+static inline struct Agn2 ___operator_assign__F5sAgn2_5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__R5sAgn2_1)));
+    ((void)___constructor__F_5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), (*___dst__5sAgn2_1)));
     return ___ret__5sAgn2_1;
+}
 …
     __attribute__ ((unused,unused)) signed int *__f9__Pi_1;
 };
 static inline void ___constructor__F_R4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1);
 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1);
 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, __attribute__ ((unused)) signed int __f1__i_1);
 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) 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).__f2__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdl4sFdl_autogen___1(struct Fdl *___dst__R4sFdl_1, struct Fdl ___src__4sFdl_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__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) /* ?{} */);
+}
 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).__f6__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ^?{} */);
     ((void)((*___dst__R4sFdl_1).__f1__i_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_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
+static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1);
+static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1);
+static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1);
+static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1);
+static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1);
+static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1);
+static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1);
+static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1);
+static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1);
+static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1);
+static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object1);
+static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object2, __attribute__ ((unused,unused)) signed int *__f9__Pi_1);
+static inline void ___constructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
+static inline void ___destructor__F_4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1){
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ^?{} */);
+    ((void)((*___dst__4sFdl_1).__f1__i_1) /* ^?{} */);
+}
+static inline struct Fdl ___operator_assign__F4sFdl_4sFdl4sFdl_autogen___1(struct Fdl *___dst__4sFdl_1, struct Fdl ___src__4sFdl_1){
     struct Fdl ___ret__4sFdl_1;
     ((void)((*___dst__R4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     ((void)((*___dst__R4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     ((void)((*___dst__R4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     ((void)((*___dst__R4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     ((void)((*___dst__R4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     ((void)((*___dst__R4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__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), (*___dst__R4sFdl_1)));
+    ((void)((*___dst__4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
+    ((void)((*___dst__4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
+    ((void)((*___dst__4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
+    ((void)((*___dst__4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
+    ((void)((*___dst__4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
+    ((void)((*___dst__4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
+    ((void)((*___dst__4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
+    ((void)((*___dst__4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=___src__4sFdl_1.__anonymous_object0));
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    ((void)___constructor__F_4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), (*___dst__4sFdl_1)));
     return ___ret__4sFdl_1;
+}
 static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
     ((void)((*___dst__R4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f2__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f3__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f4__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f5__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f6__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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_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) /* ?{} */);
     ((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) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f8__i_1) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__anonymous_object0) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_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) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) 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).__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_object3) /* ?{} */);
     ((void)((*___dst__R4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
 static inline void ___constructor__F_R4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) 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) /* ?{} */);
+static inline void ___constructor__F_4sFdli_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdlii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiiii_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object3){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object3) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_4sFdliiiiiiiiiPi_autogen___1(struct Fdl *___dst__4sFdl_1, __attribute__ ((unused)) signed int __f1__i_1, __attribute__ ((unused)) signed int __f2__i_1, __attribute__ ((unused,unused)) signed int __f3__i_1, __attribute__ ((unused)) signed int __f4__i_1, __attribute__ ((unused,unused)) signed int __f5__i_1, signed int __f6__i_1, __attribute__ ((unused,unused)) signed int __f7__i_1, __attribute__ ((unused)) signed int __f8__i_1, __attribute__ ((unused)) signed int __anonymous_object4, __attribute__ ((unused,unused)) signed int *__f9__Pi_1){
+    ((void)((*___dst__4sFdl_1).__f1__i_1=__f1__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f2__i_1=__f2__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f3__i_1=__f3__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f4__i_1=__f4__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f5__i_1=__f5__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f6__i_1=__f6__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f7__i_1=__f7__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f8__i_1=__f8__i_1) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__anonymous_object0=__anonymous_object4) /* ?{} */);
+    ((void)((*___dst__4sFdl_1).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 __attribute__ ((unused)) signed int __f__Fi___1() asm ( "xyz" );
 …
 __attribute__ ((used,used,used)) const signed int __vd5__A0Ci_1[((unsigned int )5)];
 __attribute__ ((used,used,unused,used)) const signed int __vd6__A0Ci_1[((unsigned int )5)];
 __attribute__ ((used,used,used,used)) const signed int (*__vd7__PFCi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__PFCi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*__vd7__Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*__vd8__Fi___1)();
 __attribute__ ((unused,used)) signed int __f1__Fi___1();
 __attribute__ ((unused)) signed int __f1__Fi___1(){
     __attribute__ ((unused)) signed int ___retval_f1__i_1;
+}
 __attribute__ ((unused,unused,unused,used)) signed int **const __f2__FCPPi___1();
 __attribute__ ((unused,unused,unused)) signed int **const __f2__FCPPi___1(){
+__attribute__ ((unused,unused,unused,used)) signed int **const __f2__FPPi___1();
+__attribute__ ((unused,unused,unused)) signed int **const __f2__FPPi___1(){
     __attribute__ ((unused)) signed int **const ___retval_f2__CPPi_1;
+}
 …
     __attribute__ ((unused)) signed int (*___retval_f3__PA0i_1)[];
+}
 __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);
+__attribute__ ((unused,used,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object6);
+__attribute__ ((unused,unused)) signed int (*__f4__FFi_i____1())(signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*___retval_f4__Fi_i__1)(signed int __anonymous_object8);
+}
 signed int __vtr__Fi___1(){
 …
     __attribute__ ((unused)) signed int ___retval_ipd3__i_1;
+}
 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)());
 signed int __ipd4__Fi_PFi__PFi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__PFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__PFi___1)()){
+signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)());
+signed int __ipd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__p__Fi___1)(), __attribute__ ((unused,unused,unused)) signed int (*__q__Fi___1)()){
     __attribute__ ((unused)) signed int ___retval_ipd4__i_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_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_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
+signed int __tpr4__Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
+signed int __tpr5__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
+signed int __tpr6__Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__Foo__Fi___1)());
+signed int __tpr7__Fi_Fi_Fi_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;
 …
         signed int __i__i_2;
     };
     inline void ___constructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R13s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2) /* ^?{} */);
+    }
     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_R13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
+    inline void ___constructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ?{} */);
+    }
+    inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
+    }
+    inline void ___destructor__F_13s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2) /* ^?{} */);
+    }
+    inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
         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), (*___dst__R13s__anonymous4_2)));
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
+        ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), (*___dst__13s__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){
         ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__13s__anonymous4_2, signed int __i__i_2){
+        ((void)((*___dst__13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     ((void)sizeof(struct __anonymous4 ));
 …
         __R__C13e__anonymous5_2,
     };
     inline void ___constructor__F_R13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__R13e__anonymous5_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) /* ?{} */);
+    }
     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){
+    inline void ___constructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
+    }
+    inline void ___constructor__F_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
+        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2) /* ?{} */);
+    }
+    inline void ___destructor__F_13e__anonymous5_intrinsic___2(__attribute__ ((unused)) enum __anonymous5 *___dst__13e__anonymous5_2){
+    }
+    inline enum __anonymous5 ___operator_assign__F13e__anonymous5_13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         enum __anonymous5 ___ret__13e__anonymous5_2;
         ((void)((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2));
         ((void)(___ret__13e__anonymous5_2=(*___dst__R13e__anonymous5_2)) /* ?{} */);
+        ((void)((*___dst__13e__anonymous5_2)=___src__13e__anonymous5_2));
+        ((void)(___ret__13e__anonymous5_2=(*___dst__13e__anonymous5_2)) /* ?{} */);
         return ___ret__13e__anonymous5_2;
+    }
 …
 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));
+signed int __apd4__Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int __apd5__Fi_Fi_i_Fi_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_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int __apd7__Fi_Fi_i_Fi_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_object32;
 …
     __attribute__ ((unused,unused)) signed int (*__anonymous_object35)();
 };
 static inline void ___constructor__F_R4sVad_autogen___1(struct Vad *___dst__R4sVad_1);
 static inline void ___constructor__F_R4sVad4sVad_autogen___1(struct Vad *___dst__R4sVad_1, struct Vad ___src__4sVad_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, __attribute__ ((unused)) signed int __anonymous_object36);
 static inline void ___constructor__F_R4sVadiPi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
 static inline void ___constructor__F_R4sVadiPiA0i_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned int )10)]);
 static inline void ___constructor__F_R4sVadiPiA0iPFi___autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned int )10)], __attribute__ ((unused,unused)) 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) /* ?{} */);
+static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
+static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1);
+static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1);
+static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object36);
+static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object37, __attribute__ ((unused,unused)) signed int *__anonymous_object38);
+static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object39, __attribute__ ((unused,unused)) signed int *__anonymous_object40, __attribute__ ((unused,unused)) signed int __anonymous_object41[((unsigned int )10)]);
+static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object42, __attribute__ ((unused,unused)) signed int *__anonymous_object43, __attribute__ ((unused,unused)) signed int __anonymous_object44[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object45)());
+static inline void ___constructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
+    {
         signed int _index0 = 0;
         for (;(_index0<10);((void)(++_index0))) {
             ((void)((*___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) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index0]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=___src__4sVad_1.__anonymous_object33) /* ?{} */);
+    {
         signed int _index1 = 0;
         for (;(_index1<10);((void)(++_index1))) {
             ((void)((*___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) /* ^?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index1]=___src__4sVad_1.__anonymous_object34[_index1]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35) /* ?{} */);
+}
+static inline void ___destructor__F_4sVad_autogen___1(struct Vad *___dst__4sVad_1){
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ^?{} */);
+    {
         signed int _index2 = (10-1);
         for (;(_index2>=0);((void)(--_index2))) {
             ((void)((*___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){
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index2]) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ^?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object32) /* ^?{} */);
+}
+static inline struct Vad ___operator_assign__F4sVad_4sVad4sVad_autogen___1(struct Vad *___dst__4sVad_1, struct Vad ___src__4sVad_1){
     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));
+    ((void)((*___dst__4sVad_1).__anonymous_object32=___src__4sVad_1.__anonymous_object32));
+    ((void)((*___dst__4sVad_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)));
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index3]=___src__4sVad_1.__anonymous_object34[_index3]));
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35=___src__4sVad_1.__anonymous_object35));
+    ((void)___constructor__F_4sVad4sVad_autogen___1((&___ret__4sVad_1), (*___dst__4sVad_1)));
     return ___ret__4sVad_1;
+}
 static inline void ___constructor__F_R4sVadi_autogen___1(struct Vad *___dst__R4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33) /* ?{} */);
+static inline void ___constructor__F_4sVadi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object46){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object46) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33) /* ?{} */);
+    {
         signed int _index4 = 0;
         for (;(_index4<10);((void)(++_index4))) {
             ((void)((*___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, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index4]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPi_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object47, __attribute__ ((unused,unused)) signed int *__anonymous_object48){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object47) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object48) /* ?{} */);
+    {
         signed int _index5 = 0;
         for (;(_index5<10);((void)(++_index5))) {
             ((void)((*___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, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned int )10)]){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index5]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPiA0i_autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object49, __attribute__ ((unused,unused)) signed int *__anonymous_object50, __attribute__ ((unused,unused)) signed int __anonymous_object51[((unsigned int )10)]){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object49) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object50) /* ?{} */);
+    {
         signed int _index6 = 0;
         for (;(_index6<10);((void)(++_index6))) {
             ((void)((*___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, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
     ((void)((*___dst__R4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
     ((void)((*___dst__R4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index6]=__anonymous_object51[_index6]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35) /* ?{} */);
+}
+static inline void ___constructor__F_4sVadiPiA0iFi___autogen___1(struct Vad *___dst__4sVad_1, __attribute__ ((unused)) signed int __anonymous_object52, __attribute__ ((unused,unused)) signed int *__anonymous_object53, __attribute__ ((unused,unused)) signed int __anonymous_object54[((unsigned int )10)], __attribute__ ((unused,unused)) signed int (*__anonymous_object55)()){
+    ((void)((*___dst__4sVad_1).__anonymous_object32=__anonymous_object52) /* ?{} */);
+    ((void)((*___dst__4sVad_1).__anonymous_object33=__anonymous_object53) /* ?{} */);
+    {
         signed int _index7 = 0;
         for (;(_index7<10);((void)(++_index7))) {
             ((void)((*___dst__R4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
+        }
+    }
     ((void)((*___dst__R4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}
+            ((void)((*___dst__4sVad_1).__anonymous_object34[_index7]=__anonymous_object54[_index7]) /* ?{} */);
+        }
+    }
+    ((void)((*___dst__4sVad_1).__anonymous_object35=__anonymous_object55) /* ?{} */);
+}

src/tests/.expect/declarationSpecifier.x64.txt

-              r3ef35bd
+              reba74ba
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_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_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_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), (*___dst__R13s__anonymous0_1)));
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
 static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_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_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
+static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
+static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_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), (*___dst__R13s__anonymous1_1)));
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
 static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_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_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
+static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
+static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_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), (*___dst__R13s__anonymous2_1)));
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
 static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_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_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
+static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
+static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_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), (*___dst__R13s__anonymous3_1)));
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
 static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_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_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
+static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
+static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_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), (*___dst__R13s__anonymous4_1)));
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
 static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_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_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
+static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
+static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_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), (*___dst__R13s__anonymous5_1)));
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
 static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_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_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
+static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
+static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_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), (*___dst__R13s__anonymous6_1)));
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
 static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_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_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
+static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
+static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_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), (*___dst__R13s__anonymous7_1)));
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
 static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_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_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
+static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
+static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1);
+static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_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), (*___dst__R13s__anonymous8_1)));
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
+    ((void)___constructor__F_13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
 static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_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_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
+static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
+static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1);
+static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_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), (*___dst__R13s__anonymous9_1)));
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
+    ((void)___constructor__F_13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
 static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_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_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
+static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
+static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_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), (*___dst__R14s__anonymous10_1)));
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
 static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_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_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
+static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
+static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_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), (*___dst__R14s__anonymous11_1)));
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
 static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_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_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
+static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
+static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_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), (*___dst__R14s__anonymous12_1)));
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
 static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_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_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
+static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
+static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_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), (*___dst__R14s__anonymous13_1)));
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
 static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_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_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
+static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
+static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_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), (*___dst__R14s__anonymous14_1)));
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
 static inline void ___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_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_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
+static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
+static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_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), (*___dst__R14s__anonymous15_1)));
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
 static inline volatile const signed int __f11__FCVi___1();
 static inline volatile const signed int __f12__FCVi___1();
 static inline volatile const signed int __f13__FCVi___1();
 static inline volatile const signed int __f14__FCVi___1();
 static inline volatile const signed int __f15__FCVi___1();
 static inline volatile const signed int __f16__FCVi___1();
 static inline volatile const signed int __f17__FCVi___1();
 static inline volatile const signed int __f18__FCVi___1();
 static inline volatile const signed short int __f21__FCVs___1();
 static inline volatile const signed short int __f22__FCVs___1();
 static inline volatile const signed short int __f23__FCVs___1();
 static inline volatile const signed short int __f24__FCVs___1();
 static inline volatile const signed short int __f25__FCVs___1();
 static inline volatile const signed short int __f26__FCVs___1();
 static inline volatile const signed short int __f27__FCVs___1();
 static inline volatile const signed short int __f28__FCVs___1();
+static inline volatile const signed int __f11__Fi___1();
+static inline volatile const signed int __f12__Fi___1();
+static inline volatile const signed int __f13__Fi___1();
+static inline volatile const signed int __f14__Fi___1();
+static inline volatile const signed int __f15__Fi___1();
+static inline volatile const signed int __f16__Fi___1();
+static inline volatile const signed int __f17__Fi___1();
+static inline volatile const signed int __f18__Fi___1();
+static inline volatile const signed short int __f21__Fs___1();
+static inline volatile const signed short int __f22__Fs___1();
+static inline volatile const signed short int __f23__Fs___1();
+static inline volatile const signed short int __f24__Fs___1();
+static inline volatile const signed short int __f25__Fs___1();
+static inline volatile const signed short int __f26__Fs___1();
+static inline volatile const signed short int __f27__Fs___1();
+static inline volatile const signed short int __f28__Fs___1();
 struct __anonymous16 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
 static inline void ___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_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_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
+static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
+static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_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), (*___dst__R14s__anonymous16_1)));
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
+static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous16 __f31__F14s__anonymous16___1();
 struct __anonymous17 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
 static inline void ___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_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_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
+static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
+static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_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), (*___dst__R14s__anonymous17_1)));
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
+static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous17 __f32__F14s__anonymous17___1();
 struct __anonymous18 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
 static inline void ___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_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_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
+static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
+static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_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), (*___dst__R14s__anonymous18_1)));
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
+static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous18 __f33__F14s__anonymous18___1();
 struct __anonymous19 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
 static inline void ___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_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_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
+static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
+static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_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), (*___dst__R14s__anonymous19_1)));
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
+static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous19 __f34__F14s__anonymous19___1();
 struct __anonymous20 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
 static inline void ___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_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_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
+static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
+static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_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), (*___dst__R14s__anonymous20_1)));
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
+static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous20 __f35__F14s__anonymous20___1();
 struct __anonymous21 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
 static inline void ___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_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_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
+static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
+static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_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), (*___dst__R14s__anonymous21_1)));
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
+static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous21 __f36__F14s__anonymous21___1();
 struct __anonymous22 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
 static inline void ___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_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_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
+static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
+static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_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), (*___dst__R14s__anonymous22_1)));
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
+static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous22 __f37__F14s__anonymous22___1();
 struct __anonymous23 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
 static inline void ___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_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_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
+static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
+static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_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), (*___dst__R14s__anonymous23_1)));
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
 static inline volatile const signed short int __f41__FCVs___1();
 static inline volatile const signed short int __f42__FCVs___1();
 static inline volatile const signed short int __f43__FCVs___1();
 static inline volatile const signed short int __f44__FCVs___1();
 static inline volatile const signed short int __f45__FCVs___1();
 static inline volatile const signed short int __f46__FCVs___1();
 static inline volatile const signed short int __f47__FCVs___1();
 static inline volatile const signed short int __f48__FCVs___1();
+static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous23 __f38__F14s__anonymous23___1();
+static inline volatile const signed short int __f41__Fs___1();
+static inline volatile const signed short int __f42__Fs___1();
+static inline volatile const signed short int __f43__Fs___1();
+static inline volatile const signed short int __f44__Fs___1();
+static inline volatile const signed short int __f45__Fs___1();
+static inline volatile const signed short int __f46__Fs___1();
+static inline volatile const signed short int __f47__Fs___1();
+static inline volatile const signed short int __f48__Fs___1();
 signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     __attribute__ ((unused)) signed int ___retval_main__i_1;

src/tests/.expect/declarationSpecifier.x86.txt

-              r3ef35bd
+              reba74ba
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1);
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous0_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_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_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1);
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
+static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_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), (*___dst__R13s__anonymous0_1)));
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__13s__anonymous0_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1);
 static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous1_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_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_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
+static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1);
+static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
+static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_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), (*___dst__R13s__anonymous1_1)));
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__13s__anonymous1_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1);
 static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous2_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_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_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
+static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1);
+static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
+static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_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), (*___dst__R13s__anonymous2_1)));
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__13s__anonymous2_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1);
 static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous3_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_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_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
+static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1);
+static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
+static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_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), (*___dst__R13s__anonymous3_1)));
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__13s__anonymous3_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1);
 static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous4_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_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_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
+static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1);
+static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
+static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_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), (*___dst__R13s__anonymous4_1)));
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__13s__anonymous4_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1);
 static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous5_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_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_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
+static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1);
+static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
+static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_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), (*___dst__R13s__anonymous5_1)));
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__13s__anonymous5_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1);
 static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous6_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_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_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
+static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1);
+static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
+static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_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), (*___dst__R13s__anonymous6_1)));
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__13s__anonymous6_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1);
 static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous7_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_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_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
+static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1);
+static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
+static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1);
+static inline void ___constructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_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), (*___dst__R13s__anonymous7_1)));
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
+    ((void)___constructor__F_13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__13s__anonymous7_1, signed int __i__i_1){
+    ((void)((*___dst__13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1);
 static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous8_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_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_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
+static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1);
+static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
+static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1);
+static inline void ___constructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_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), (*___dst__R13s__anonymous8_1)));
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
+    ((void)___constructor__F_13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__13s__anonymous8_1, signed short int __i__s_1){
+    ((void)((*___dst__13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1);
 static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_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) /* ?{} */);
+}
 static inline void ___constructor__F_R13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R13s__anonymous9_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_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_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
+static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1);
+static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
+static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1);
+static inline void ___constructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_13s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_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), (*___dst__R13s__anonymous9_1)));
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
+    ((void)___constructor__F_13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), (*___dst__13s__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){
     ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__13s__anonymous9_1, signed short int __i__s_1){
+    ((void)((*___dst__13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1);
 static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous10_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_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_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
+static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1);
+static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
+static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_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), (*___dst__R14s__anonymous10_1)));
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__14s__anonymous10_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1);
 static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous11_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_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_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
+static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1);
+static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
+static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_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), (*___dst__R14s__anonymous11_1)));
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__14s__anonymous11_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1);
 static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous12_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_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_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
+static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1);
+static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
+static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_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), (*___dst__R14s__anonymous12_1)));
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__14s__anonymous12_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1);
 static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous13_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_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_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
+static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1);
+static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
+static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_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), (*___dst__R14s__anonymous13_1)));
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__14s__anonymous13_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1);
 static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous14_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_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_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
+static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1);
+static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
+static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_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), (*___dst__R14s__anonymous14_1)));
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__14s__anonymous14_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
 …
     signed short int __i__s_1;
 };
 static inline void ___constructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1);
 static inline void ___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous15_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_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_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
+static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1);
+static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
+static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1);
+static inline void ___constructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1) /* ^?{} */);
+}
+static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_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), (*___dst__R14s__anonymous15_1)));
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
+    ((void)___constructor__F_14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__14s__anonymous15_1, signed short int __i__s_1){
+    ((void)((*___dst__14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
 static inline volatile const signed int __f11__FCVi___1();
 static inline volatile const signed int __f12__FCVi___1();
 static inline volatile const signed int __f13__FCVi___1();
 static inline volatile const signed int __f14__FCVi___1();
 static inline volatile const signed int __f15__FCVi___1();
 static inline volatile const signed int __f16__FCVi___1();
 static inline volatile const signed int __f17__FCVi___1();
 static inline volatile const signed int __f18__FCVi___1();
 static inline volatile const signed short int __f21__FCVs___1();
 static inline volatile const signed short int __f22__FCVs___1();
 static inline volatile const signed short int __f23__FCVs___1();
 static inline volatile const signed short int __f24__FCVs___1();
 static inline volatile const signed short int __f25__FCVs___1();
 static inline volatile const signed short int __f26__FCVs___1();
 static inline volatile const signed short int __f27__FCVs___1();
 static inline volatile const signed short int __f28__FCVs___1();
+static inline volatile const signed int __f11__Fi___1();
+static inline volatile const signed int __f12__Fi___1();
+static inline volatile const signed int __f13__Fi___1();
+static inline volatile const signed int __f14__Fi___1();
+static inline volatile const signed int __f15__Fi___1();
+static inline volatile const signed int __f16__Fi___1();
+static inline volatile const signed int __f17__Fi___1();
+static inline volatile const signed int __f18__Fi___1();
+static inline volatile const signed short int __f21__Fs___1();
+static inline volatile const signed short int __f22__Fs___1();
+static inline volatile const signed short int __f23__Fs___1();
+static inline volatile const signed short int __f24__Fs___1();
+static inline volatile const signed short int __f25__Fs___1();
+static inline volatile const signed short int __f26__Fs___1();
+static inline volatile const signed short int __f27__Fs___1();
+static inline volatile const signed short int __f28__Fs___1();
 struct __anonymous16 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1);
 static inline void ___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous16_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_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_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
+static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1);
+static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
+static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_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), (*___dst__R14s__anonymous16_1)));
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous16 __f31__FCV14s__anonymous16___1();
+static inline void ___constructor__F_14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__14s__anonymous16_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous16_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous16 __f31__F14s__anonymous16___1();
 struct __anonymous17 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1);
 static inline void ___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous17_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_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_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
+static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1);
+static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
+static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_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), (*___dst__R14s__anonymous17_1)));
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous17 __f32__FCV14s__anonymous17___1();
+static inline void ___constructor__F_14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__14s__anonymous17_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous17_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous17 __f32__F14s__anonymous17___1();
 struct __anonymous18 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1);
 static inline void ___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous18_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_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_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
+static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1);
+static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
+static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_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), (*___dst__R14s__anonymous18_1)));
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous18 __f33__FCV14s__anonymous18___1();
+static inline void ___constructor__F_14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__14s__anonymous18_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous18_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous18 __f33__F14s__anonymous18___1();
 struct __anonymous19 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1);
 static inline void ___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous19_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_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_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
+static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1);
+static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
+static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_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), (*___dst__R14s__anonymous19_1)));
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous19 __f34__FCV14s__anonymous19___1();
+static inline void ___constructor__F_14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__14s__anonymous19_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous19_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous19 __f34__F14s__anonymous19___1();
 struct __anonymous20 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1);
 static inline void ___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous20_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_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_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
+static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1);
+static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
+static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_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), (*___dst__R14s__anonymous20_1)));
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous20 __f35__FCV14s__anonymous20___1();
+static inline void ___constructor__F_14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__14s__anonymous20_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous20_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous20 __f35__F14s__anonymous20___1();
 struct __anonymous21 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1);
 static inline void ___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous21_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_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_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
+static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1);
+static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
+static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_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), (*___dst__R14s__anonymous21_1)));
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous21 __f36__FCV14s__anonymous21___1();
+static inline void ___constructor__F_14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__14s__anonymous21_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous21_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous21 __f36__F14s__anonymous21___1();
 struct __anonymous22 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1);
 static inline void ___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous22_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_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_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
+static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1);
+static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
+static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_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), (*___dst__R14s__anonymous22_1)));
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous22 __f37__FCV14s__anonymous22___1();
+static inline void ___constructor__F_14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__14s__anonymous22_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous22_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous22 __f37__F14s__anonymous22___1();
 struct __anonymous23 {
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1);
 static inline void ___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_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) /* ?{} */);
+}
 static inline void ___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R14s__anonymous23_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_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_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
+static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1);
+static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
+static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1);
+static inline void ___constructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_14s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1) /* ^?{} */);
+}
+static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_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), (*___dst__R14s__anonymous23_1)));
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
+    ((void)___constructor__F_14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), (*___dst__14s__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){
     ((void)((*___dst__R14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static inline volatile const struct __anonymous23 __f38__FCV14s__anonymous23___1();
 static inline volatile const signed short int __f41__FCVs___1();
 static inline volatile const signed short int __f42__FCVs___1();
 static inline volatile const signed short int __f43__FCVs___1();
 static inline volatile const signed short int __f44__FCVs___1();
 static inline volatile const signed short int __f45__FCVs___1();
 static inline volatile const signed short int __f46__FCVs___1();
 static inline volatile const signed short int __f47__FCVs___1();
 static inline volatile const signed short int __f48__FCVs___1();
+static inline void ___constructor__F_14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__14s__anonymous23_1, signed int __i__i_1){
+    ((void)((*___dst__14s__anonymous23_1).__i__i_1=__i__i_1) /* ?{} */);
+}
+static inline volatile const struct __anonymous23 __f38__F14s__anonymous23___1();
+static inline volatile const signed short int __f41__Fs___1();
+static inline volatile const signed short int __f42__Fs___1();
+static inline volatile const signed short int __f43__Fs___1();
+static inline volatile const signed short int __f44__Fs___1();
+static inline volatile const signed short int __f45__Fs___1();
+static inline volatile const signed short int __f46__Fs___1();
+static inline volatile const signed short int __f47__Fs___1();
+static inline volatile const signed short int __f48__Fs___1();
 signed int __main__Fi_iPPCc__1(signed int __argc__i_1, const char **__argv__PPCc_1){
     __attribute__ ((unused)) signed int ___retval_main__i_1;

src/tests/.expect/extension.x64.txt

-              r3ef35bd
+              reba74ba
     __extension__ signed int __c__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
 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) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     ((void)((*___dst__R2sS_1).__a__i_1=___src__2sS_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) /* ?{} */);
+}
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__c__i_1) /* ^?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1) /* ^?{} */);
     ((void)((*___dst__R2sS_1).__a__i_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_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1);
+static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1);
+static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__c__i_1) /* ^?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1) /* ^?{} */);
+    ((void)((*___dst__2sS_1).__a__i_1) /* ^?{} */);
+}
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     struct S ___ret__2sS_1;
     ((void)((*___dst__R2sS_1).__a__i_1=___src__2sS_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), (*___dst__R2sS_1)));
+    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
+    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
+    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
+    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__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){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__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){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1=__c__i_1) /* ?{} */);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1){
+    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1){
+    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
+    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1=__c__i_1) /* ?{} */);
+}
 __extension__ union U {
 …
     __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){
+}
 static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1){
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+}
 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_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
+static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
+static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
+static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
+static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1);
+static inline void ___constructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
+}
+static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1){
+    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+}
+static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
+}
+static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_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), (*___dst__R2uU_1)));
+    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    ((void)___constructor__F_2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__2uU_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 )));
+static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
+}
 __extension__ enum E {
 …
         __extension__ signed int *__z__Pi_2;
     };
     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){
+    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
+    }
+    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
+    }
+    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_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)));
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
+        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
+        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
+        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_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) /* ?{} */);
+    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiiiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiiiPiPi_autogen___2(struct S *___dst__2sS_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__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiiiPiPiPi_autogen___2(struct S *___dst__2sS_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__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
+    }
     signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);

src/tests/.expect/extension.x86.txt

-              r3ef35bd
+              reba74ba
     __extension__ signed int __c__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
 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) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     ((void)((*___dst__R2sS_1).__a__i_1=___src__2sS_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) /* ?{} */);
+}
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__c__i_1) /* ^?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1) /* ^?{} */);
     ((void)((*___dst__R2sS_1).__a__i_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_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1);
+static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1);
+static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__c__i_1) /* ^?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1) /* ^?{} */);
+    ((void)((*___dst__2sS_1).__a__i_1) /* ^?{} */);
+}
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
     struct S ___ret__2sS_1;
     ((void)((*___dst__R2sS_1).__a__i_1=___src__2sS_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), (*___dst__R2sS_1)));
+    ((void)((*___dst__2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
+    ((void)((*___dst__2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
+    ((void)((*___dst__2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
+    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __a__i_1){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__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){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__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){
     ((void)((*___dst__R2sS_1).__a__i_1=__a__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__b__i_1=__b__i_1) /* ?{} */);
     ((void)((*___dst__R2sS_1).__c__i_1=__c__i_1) /* ?{} */);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1){
+    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sSii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1){
+    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sSiii_autogen___1(struct S *___dst__2sS_1, signed int __a__i_1, signed int __b__i_1, signed int __c__i_1){
+    ((void)((*___dst__2sS_1).__a__i_1=__a__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__b__i_1=__b__i_1) /* ?{} */);
+    ((void)((*___dst__2sS_1).__c__i_1=__c__i_1) /* ?{} */);
+}
 __extension__ union U {
 …
     __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){
+}
 static inline void ___constructor__F_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1){
     ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+}
 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_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
+static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
+static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1);
+static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1);
+static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1);
+static inline void ___constructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
+}
+static inline void ___constructor__F_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_1){
+    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+}
+static inline void ___destructor__F_2uU_autogen___1(__attribute__ ((unused)) union U *___dst__2uU_1){
+}
+static inline union U ___operator_assign__F2uU_2uU2uU_autogen___1(union U *___dst__2uU_1, union U ___src__2uU_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), (*___dst__R2uU_1)));
+    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    ((void)___constructor__F_2uU2uU_autogen___1((&___ret__2uU_1), (*___dst__2uU_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 )));
+static inline void ___constructor__F_2uUi_autogen___1(union U *___dst__2uU_1, signed int __a__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__2uU_1), ((const void *)(&__a__i_1)), sizeof(signed int )));
+}
 __extension__ enum E {
 …
         __extension__ signed int *__z__Pi_2;
     };
     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){
+    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2) /* ?{} */);
+    }
+    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
+    }
+    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_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)));
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)((*___dst__2sS_2).__x__Pi_2=___src__2sS_2.__x__Pi_2));
+        ((void)((*___dst__2sS_2).__y__Pi_2=___src__2sS_2.__y__Pi_2));
+        ((void)((*___dst__2sS_2).__z__Pi_2=___src__2sS_2.__z__Pi_2));
+        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_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) /* ?{} */);
+    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiiiPi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2, signed int *__x__Pi_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiiiPiPi_autogen___2(struct S *___dst__2sS_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__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2) /* ?{} */);
+    }
+    inline void ___constructor__F_2sSiiiPiPiPi_autogen___2(struct S *___dst__2sS_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__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__x__Pi_2=__x__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__y__Pi_2=__y__Pi_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__z__Pi_2=__z__Pi_2) /* ?{} */);
+    }
     signed int __i__i_2 = (__extension__ __a__i_1+__extension__ 3);

src/tests/.expect/functions.x64.txt

-              r3ef35bd
+              reba74ba
 void __h__F___1(void){
+}
 signed int __f__Fi_PFi__PFi_i_PFi__PFi_i_PF____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*__g__PF___1)(void)){
     __attribute__ ((unused)) signed int ___retval_f__i_1;
     ((void)(*__g__PF___1)());
     ((void)__g__PF___1());
     ((void)(__g__PF___1=__h__F___1));
+signed int __f__Fi_Fi__Fi_i_Fi__Fi_i_F____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*__g__F___1)(void)){
+    __attribute__ ((unused)) signed int ___retval_f__i_1;
+    ((void)(*__g__F___1)());
+    ((void)__g__F___1());
+    ((void)(__g__F___1=__h__F___1));
+}
 signed int __f1__Fi___1(){
 …
     __attribute__ ((unused)) signed int ___retval_f2__i_1;
+}
 signed int (*__f3__FPFi_____1())(){
     __attribute__ ((unused)) signed int (*___retval_f3__PFi___1)();
+signed int (*__f3__FFi_____1())(){
+    __attribute__ ((unused)) signed int (*___retval_f3__Fi___1)();
+}
 signed int *__f4__FPi___1(){
     __attribute__ ((unused)) signed int *___retval_f4__Pi_1;
+}
 signed int (*__f5__FPFi_____1())(){
     __attribute__ ((unused)) signed int (*___retval_f5__PFi___1)();
+signed int (*__f5__FFi_____1())(){
+    __attribute__ ((unused)) signed int (*___retval_f5__Fi___1)();
+}
 signed int *__f6__FPi___1(){
 …
     __attribute__ ((unused)) signed int ___retval_fII1__i_1;
+}
 const signed int __fII2__FCi_i__1(signed int __i__i_1){
+const signed int __fII2__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fII2__Ci_1;
+}
 …
     __attribute__ ((unused)) signed int ___retval_fII3__i_1;
+}
 extern const signed int __fII4__FCi_i__1(signed int __i__i_1){
+extern const signed int __fII4__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fII4__Ci_1;
+}
 …
     __attribute__ ((unused)) signed int *___retval_fII5__Pi_1;
+}
 signed int *const __fII6__FCPi___1(){
+signed int *const __fII6__FPi___1(){
     __attribute__ ((unused)) signed int *const ___retval_fII6__CPi_1;
+}
 …
     __attribute__ ((unused)) signed int ___retval_fO2__i_1;
+}
 const signed int __fO3__FCi_i__1(signed int __i__i_1){
+const signed int __fO3__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fO3__Ci_1;
+}
 …
     __attribute__ ((unused)) signed int ___retval_fO4__i_1;
+}
 extern const signed int __fO5__FCi_i__1(signed int __i__i_1){
+extern const signed int __fO5__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fO5__Ci_1;
+}
 …
 signed int __f11__Fi_i__1(signed int __anonymous_object16);
 signed int __f12__Fi___1(void);
 const double __bar1__FCd___1();
 const double __bar2__FCd_i__1(signed int __anonymous_object17);
 const double __bar3__FCd_d__1(double __anonymous_object18);
 const double __foo__FCd___1(void);
 const double __foo__FCd_i__1(signed int __anonymous_object19);
 const double __foo__FCd_d__1(double __anonymous_object20){
+const double __bar1__Fd___1();
+const double __bar2__Fd_i__1(signed int __anonymous_object17);
+const double __bar3__Fd_d__1(double __anonymous_object18);
+const double __foo__Fd___1(void);
+const double __foo__Fd_i__1(signed int __anonymous_object19);
+const double __foo__Fd_d__1(double __anonymous_object20){
     __attribute__ ((unused)) const double ___retval_foo__Cd_1;
     ((void)((*((double *)(&___retval_foo__Cd_1)))=3.0) /* ?{} */);
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
 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) /* ?{} */);
+}
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_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_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
+}
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_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), (*___dst__R2sS_1)));
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
+    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 struct S __rtn__F2sS_i__1(signed int __anonymous_object21){
     __attribute__ ((unused)) struct S ___retval_rtn__2sS_1;
+}
 signed int __f__Fi_PFi_ii_PFi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int __p__i_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
+signed int __f__Fi_Fi_ii_Fi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int __p__i_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
     __attribute__ ((unused)) signed int ___retval_f__i_1;
     signed int (*(*__pc__PA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
     signed int (*(*__p__PA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
     signed int (*(*__p__PA0PFi_i__2)[])(signed int __anonymous_object26);
+    signed int (*(*__p__PA0Fi_i__2)[])(signed int __anonymous_object26);
+}
 static const signed int *__f1__FPCi___1(){
     __attribute__ ((unused)) const signed int *___retval_f1__PCi_1;
+}
 static const signed int __f2__FCi___1(void){
     __attribute__ ((unused)) const signed int ___retval_f2__Ci_1;
+}
 static inline signed int *const __f3__FCPi___1(void){
+static const signed int *__f2__FPCi___1(void){
+    __attribute__ ((unused)) const signed int *___retval_f2__PCi_1;
+}
+static inline signed int *const __f3__FPi___1(void){
     __attribute__ ((unused)) signed int *const ___retval_f3__CPi_1;
+}
 …
     signed int field_1;
 };
 static inline const struct _conc__tuple2_3 __f4__FCTPii____1(void){
+static inline const struct _conc__tuple2_3 __f4__FTPii____1(void){
     __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f4__CTPii__1;
+}
 static const struct _conc__tuple2_3 __f5__FCTPiCi____1(void){
+static const struct _conc__tuple2_3 __f5__FTPiCi____1(void){
     __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f5__CTPiCi__1;
+}
 signed int __f__Fi_PFi__PFPi__PFPPi__PFPCPi__PFCPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned long int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned long int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned long int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned long int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned long int )10)]);
 signed int __f__Fi_PFi__PFPi__PFPPi__PFPCPi__PFCPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned long int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned long int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned long int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned long int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned long int )10)]){
+signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned long int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned long int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned long int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned long int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned long int )10)]);
+signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned long int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned long int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned long int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned long int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned long int )10)]){
     __attribute__ ((unused)) signed int ___retval_f__i_1;
+}

src/tests/.expect/functions.x86.txt

-              r3ef35bd
+              reba74ba
 void __h__F___1(void){
+}
 signed int __f__Fi_PFi__PFi_i_PFi__PFi_i_PF____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*__g__PF___1)(void)){
     __attribute__ ((unused)) signed int ___retval_f__i_1;
     ((void)(*__g__PF___1)());
     ((void)__g__PF___1());
     ((void)(__g__PF___1=__h__F___1));
+signed int __f__Fi_Fi__Fi_i_Fi__Fi_i_F____1(signed int (*__anonymous_object0)(void), signed int (*__anonymous_object1)(signed int __anonymous_object2), signed int (*__anonymous_object3)(void), signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*__g__F___1)(void)){
+    __attribute__ ((unused)) signed int ___retval_f__i_1;
+    ((void)(*__g__F___1)());
+    ((void)__g__F___1());
+    ((void)(__g__F___1=__h__F___1));
+}
 signed int __f1__Fi___1(){
 …
     __attribute__ ((unused)) signed int ___retval_f2__i_1;
+}
 signed int (*__f3__FPFi_____1())(){
     __attribute__ ((unused)) signed int (*___retval_f3__PFi___1)();
+signed int (*__f3__FFi_____1())(){
+    __attribute__ ((unused)) signed int (*___retval_f3__Fi___1)();
+}
 signed int *__f4__FPi___1(){
     __attribute__ ((unused)) signed int *___retval_f4__Pi_1;
+}
 signed int (*__f5__FPFi_____1())(){
     __attribute__ ((unused)) signed int (*___retval_f5__PFi___1)();
+signed int (*__f5__FFi_____1())(){
+    __attribute__ ((unused)) signed int (*___retval_f5__Fi___1)();
+}
 signed int *__f6__FPi___1(){
 …
     __attribute__ ((unused)) signed int ___retval_fII1__i_1;
+}
 const signed int __fII2__FCi_i__1(signed int __i__i_1){
+const signed int __fII2__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fII2__Ci_1;
+}
 …
     __attribute__ ((unused)) signed int ___retval_fII3__i_1;
+}
 extern const signed int __fII4__FCi_i__1(signed int __i__i_1){
+extern const signed int __fII4__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fII4__Ci_1;
+}
 …
     __attribute__ ((unused)) signed int *___retval_fII5__Pi_1;
+}
 signed int *const __fII6__FCPi___1(){
+signed int *const __fII6__FPi___1(){
     __attribute__ ((unused)) signed int *const ___retval_fII6__CPi_1;
+}
 …
     __attribute__ ((unused)) signed int ___retval_fO2__i_1;
+}
 const signed int __fO3__FCi_i__1(signed int __i__i_1){
+const signed int __fO3__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fO3__Ci_1;
+}
 …
     __attribute__ ((unused)) signed int ___retval_fO4__i_1;
+}
 extern const signed int __fO5__FCi_i__1(signed int __i__i_1){
+extern const signed int __fO5__Fi_i__1(signed int __i__i_1){
     __attribute__ ((unused)) const signed int ___retval_fO5__Ci_1;
+}
 …
 signed int __f11__Fi_i__1(signed int __anonymous_object16);
 signed int __f12__Fi___1(void);
 const double __bar1__FCd___1();
 const double __bar2__FCd_i__1(signed int __anonymous_object17);
 const double __bar3__FCd_d__1(double __anonymous_object18);
 const double __foo__FCd___1(void);
 const double __foo__FCd_i__1(signed int __anonymous_object19);
 const double __foo__FCd_d__1(double __anonymous_object20){
+const double __bar1__Fd___1();
+const double __bar2__Fd_i__1(signed int __anonymous_object17);
+const double __bar3__Fd_d__1(double __anonymous_object18);
+const double __foo__Fd___1(void);
+const double __foo__Fd_i__1(signed int __anonymous_object19);
+const double __foo__Fd_d__1(double __anonymous_object20){
     __attribute__ ((unused)) const double ___retval_foo__Cd_1;
     ((void)((*((double *)(&___retval_foo__Cd_1)))=3.0) /* ?{} */);
 …
     signed int __i__i_1;
 };
 static inline void ___constructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1);
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1);
 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) /* ?{} */);
+}
 static inline void ___constructor__F_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_R2sS_autogen___1(struct S *___dst__R2sS_1){
     ((void)((*___dst__R2sS_1).__i__i_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_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1);
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1);
+static inline void ___constructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_2sS_autogen___1(struct S *___dst__2sS_1){
+    ((void)((*___dst__2sS_1).__i__i_1) /* ^?{} */);
+}
+static inline struct S ___operator_assign__F2sS_2sS2sS_autogen___1(struct S *___dst__2sS_1, struct S ___src__2sS_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), (*___dst__R2sS_1)));
+    ((void)((*___dst__2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    ((void)___constructor__F_2sS2sS_autogen___1((&___ret__2sS_1), (*___dst__2sS_1)));
     return ___ret__2sS_1;
+}
 static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, signed int __i__i_1){
     ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_2sSi_autogen___1(struct S *___dst__2sS_1, signed int __i__i_1){
+    ((void)((*___dst__2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 struct S __rtn__F2sS_i__1(signed int __anonymous_object21){
     __attribute__ ((unused)) struct S ___retval_rtn__2sS_1;
+}
 signed int __f__Fi_PFi_ii_PFi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int __p__i_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
+signed int __f__Fi_Fi_ii_Fi_i___1(signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int __p__i_1), signed int (*__anonymous_object24)(signed int __anonymous_object25)){
     __attribute__ ((unused)) signed int ___retval_f__i_1;
     signed int (*(*__pc__PA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     signed int (*(*__p__PA0A0PA0A0i_2)[][((unsigned int )10)])[][((unsigned int )3)];
     signed int (*(*__p__PA0PFi_i__2)[])(signed int __anonymous_object26);
+    signed int (*(*__p__PA0Fi_i__2)[])(signed int __anonymous_object26);
+}
 static const signed int *__f1__FPCi___1(){
     __attribute__ ((unused)) const signed int *___retval_f1__PCi_1;
+}
 static const signed int __f2__FCi___1(void){
     __attribute__ ((unused)) const signed int ___retval_f2__Ci_1;
+}
 static inline signed int *const __f3__FCPi___1(void){
+static const signed int *__f2__FPCi___1(void){
+    __attribute__ ((unused)) const signed int *___retval_f2__PCi_1;
+}
+static inline signed int *const __f3__FPi___1(void){
     __attribute__ ((unused)) signed int *const ___retval_f3__CPi_1;
+}
 …
     signed int field_1;
 };
 static inline const struct _conc__tuple2_3 __f4__FCTPii____1(void){
+static inline const struct _conc__tuple2_3 __f4__FTPii____1(void){
     __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f4__CTPii__1;
+}
 static const struct _conc__tuple2_3 __f5__FCTPiCi____1(void){
+static const struct _conc__tuple2_3 __f5__FTPiCi____1(void){
     __attribute__ ((unused)) const struct _conc__tuple2_3 ___retval_f5__CTPiCi__1;
+}
 signed int __f__Fi_PFi__PFPi__PFPPi__PFPCPi__PFCPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned int )10)]);
 signed int __f__Fi_PFi__PFPi__PFPPi__PFPCPi__PFCPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned int )10)]){
+signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned int )10)]);
+signed int __f__Fi_Fi__FPi__FPPi__FPCPi__FPCPi__PiPiPPiPPiPPPiPPPiPPCPiPPCPiPCPCPiPCPCPi__1(signed int (*__anonymous_object42)(), signed int *(*__anonymous_object43)(), signed int **(*__anonymous_object44)(), signed int *const *(*__anonymous_object45)(), signed int *const *const (*__anonymous_object46)(), signed int *__anonymous_object47, signed int __anonymous_object48[((unsigned int )10)], signed int **__anonymous_object49, signed int *__anonymous_object50[((unsigned int )10)], signed int ***__anonymous_object51, signed int **__anonymous_object52[((unsigned int )10)], signed int *const **__anonymous_object53, signed int *const *__anonymous_object54[((unsigned int )10)], signed int *const *const *__anonymous_object55, signed int *const *const __anonymous_object56[((unsigned int )10)]){
     __attribute__ ((unused)) signed int ___retval_f__i_1;
+}

src/tests/.expect/gccExtensions.x64.txt

-              r3ef35bd
+              reba74ba
         __extension__ signed int __c__i_2;
     };
     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) /* ?{} */);
+    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_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) /* ?{} */);
+    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
         ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */);
         ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */);
+    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
+    }
     inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_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)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_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) /* ?{} */);
+    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_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) /* ?{} */);
+    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_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) /* ?{} */);
+    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+    }
     signed int __i__i_2 = __extension__ 3;
 …
         signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
         ((void)((*___dst__R3ss2_2).__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
+        ((void)((*___dst__3ss2_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_2){
+        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
         ((void)((*___dst__R3ss2_2).__i__i_2) /* ^?{} */);
+    inline void ___destructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
+        ((void)((*___dst__3ss2_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s2 ___operator_assign__F3ss2_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){
+    inline struct s2 ___operator_assign__F3ss2_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_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), (*___dst__R3ss2_2)));
+        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        ((void)___constructor__F_3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__3ss2_2)));
         return ___ret__3ss2_2;
+    }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
         ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss2i_autogen___2(struct s2 *___dst__3ss2_2, signed int __i__i_2){
+        ((void)((*___dst__3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 {
         signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
         ((void)((*___dst__R3ss3_2).__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
+        ((void)((*___dst__3ss3_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_2){
+        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
         ((void)((*___dst__R3ss3_2).__i__i_2) /* ^?{} */);
+    inline void ___destructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
+        ((void)((*___dst__3ss3_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s3 ___operator_assign__F3ss3_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){
+    inline struct s3 ___operator_assign__F3ss3_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_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), (*___dst__R3ss3_2)));
+        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        ((void)___constructor__F_3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__3ss3_2)));
         return ___ret__3ss3_2;
+    }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
         ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss3i_autogen___2(struct s3 *___dst__3ss3_2, signed int __i__i_2){
+        ((void)((*___dst__3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 __x1__3ss3_2;
 …
         signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
         ((void)((*___dst__R3ss4_2).__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
+        ((void)((*___dst__3ss4_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_2){
+        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
         ((void)((*___dst__R3ss4_2).__i__i_2) /* ^?{} */);
+    inline void ___destructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
+        ((void)((*___dst__3ss4_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s4 ___operator_assign__F3ss4_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){
+    inline struct s4 ___operator_assign__F3ss4_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_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), (*___dst__R3ss4_2)));
+        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        ((void)___constructor__F_3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__3ss4_2)));
         return ___ret__3ss4_2;
+    }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
         ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss4i_autogen___2(struct s4 *___dst__3ss4_2, signed int __i__i_2){
+        ((void)((*___dst__3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s4 __x2__3ss4_2;

src/tests/.expect/gccExtensions.x86.txt

-              r3ef35bd
+              reba74ba
         __extension__ signed int __c__i_2;
     };
     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) /* ?{} */);
+    inline void ___constructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_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) /* ?{} */);
+    inline void ___constructor__F_2sS2sS_autogen___2(struct S *___dst__2sS_2, struct S ___src__2sS_2){
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R2sS_autogen___2(struct S *___dst__R2sS_2){
         ((void)((*___dst__R2sS_2).__c__i_2) /* ^?{} */);
         ((void)((*___dst__R2sS_2).__b__i_2) /* ^?{} */);
         ((void)((*___dst__R2sS_2).__a__i_2) /* ^?{} */);
+    inline void ___destructor__F_2sS_autogen___2(struct S *___dst__2sS_2){
+        ((void)((*___dst__2sS_2).__c__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ^?{} */);
+        ((void)((*___dst__2sS_2).__a__i_2) /* ^?{} */);
+    }
     inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
+    inline struct S ___operator_assign__F2sS_2sS2sS_autogen___2(struct S *___dst__2sS_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)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__R2sS_2)));
+        ((void)((*___dst__2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
+        ((void)((*___dst__2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
+        ((void)((*___dst__2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        ((void)___constructor__F_2sS2sS_autogen___2((&___ret__2sS_2), (*___dst__2sS_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) /* ?{} */);
+    inline void ___constructor__F_2sSi_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_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) /* ?{} */);
+    inline void ___constructor__F_2sSii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_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) /* ?{} */);
+    inline void ___constructor__F_2sSiii_autogen___2(struct S *___dst__2sS_2, signed int __a__i_2, signed int __b__i_2, signed int __c__i_2){
+        ((void)((*___dst__2sS_2).__a__i_2=__a__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__b__i_2=__b__i_2) /* ?{} */);
+        ((void)((*___dst__2sS_2).__c__i_2=__c__i_2) /* ?{} */);
+    }
     signed int __i__i_2 = __extension__ 3;
 …
         signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
         ((void)((*___dst__R3ss2_2).__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
+        ((void)((*___dst__3ss2_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){
         ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_2){
+        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
         ((void)((*___dst__R3ss2_2).__i__i_2) /* ^?{} */);
+    inline void ___destructor__F_3ss2_autogen___2(struct s2 *___dst__3ss2_2){
+        ((void)((*___dst__3ss2_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s2 ___operator_assign__F3ss2_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){
+    inline struct s2 ___operator_assign__F3ss2_3ss23ss2_autogen___2(struct s2 *___dst__3ss2_2, struct s2 ___src__3ss2_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), (*___dst__R3ss2_2)));
+        ((void)((*___dst__3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        ((void)___constructor__F_3ss23ss2_autogen___2((&___ret__3ss2_2), (*___dst__3ss2_2)));
         return ___ret__3ss2_2;
+    }
     inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, signed int __i__i_2){
         ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss2i_autogen___2(struct s2 *___dst__3ss2_2, signed int __i__i_2){
+        ((void)((*___dst__3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 {
         signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
         ((void)((*___dst__R3ss3_2).__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
+        ((void)((*___dst__3ss3_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){
         ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_2){
+        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
         ((void)((*___dst__R3ss3_2).__i__i_2) /* ^?{} */);
+    inline void ___destructor__F_3ss3_autogen___2(struct s3 *___dst__3ss3_2){
+        ((void)((*___dst__3ss3_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s3 ___operator_assign__F3ss3_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){
+    inline struct s3 ___operator_assign__F3ss3_3ss33ss3_autogen___2(struct s3 *___dst__3ss3_2, struct s3 ___src__3ss3_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), (*___dst__R3ss3_2)));
+        ((void)((*___dst__3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        ((void)___constructor__F_3ss33ss3_autogen___2((&___ret__3ss3_2), (*___dst__3ss3_2)));
         return ___ret__3ss3_2;
+    }
     inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, signed int __i__i_2){
         ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss3i_autogen___2(struct s3 *___dst__3ss3_2, signed int __i__i_2){
+        ((void)((*___dst__3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 __x1__3ss3_2;
 …
         signed int __i__i_2;
     };
     inline void ___constructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
         ((void)((*___dst__R3ss4_2).__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
+        ((void)((*___dst__3ss4_2).__i__i_2) /* ?{} */);
+    }
     inline void ___constructor__F_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){
         ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_2){
+        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
         ((void)((*___dst__R3ss4_2).__i__i_2) /* ^?{} */);
+    inline void ___destructor__F_3ss4_autogen___2(struct s4 *___dst__3ss4_2){
+        ((void)((*___dst__3ss4_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s4 ___operator_assign__F3ss4_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){
+    inline struct s4 ___operator_assign__F3ss4_3ss43ss4_autogen___2(struct s4 *___dst__3ss4_2, struct s4 ___src__3ss4_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), (*___dst__R3ss4_2)));
+        ((void)((*___dst__3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        ((void)___constructor__F_3ss43ss4_autogen___2((&___ret__3ss4_2), (*___dst__3ss4_2)));
         return ___ret__3ss4_2;
+    }
     inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, signed int __i__i_2){
         ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_3ss4i_autogen___2(struct s4 *___dst__3ss4_2, signed int __i__i_2){
+        ((void)((*___dst__3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s4 __x2__3ss4_2;

src/tests/.expect/io2.txt

-              r3ef35bd
+              reba74ba
-6 28 0 7 1 2
-2 3
-opening delimiters
-x (1 x [2 x {3 x =4 x $5 x £6 x ¥7 x ¡8 x ¿9 x «10
-closing delimiters
-, x 2. x 3; x 4! x 5? x 6% x 7¢ x 8» x 9) x 10] x 11} x
-opening/closing delimiters
-x`1`x'2'x"3"x:4:x 5 x   6       x
+x
+x
+x
+x
-override opening/closing delimiters
-x ( 1 ) x 2 , x 3 :x: 4
 input bacis types

src/tests/.expect/literals.x64.txt

-              r3ef35bd
+              reba74ba
 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_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0b__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object103), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, _Bool __anonymous_object109);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object131), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, char __anonymous_object137);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object159), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, signed char __anonymous_object165);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object187), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, unsigned char __anonymous_object193);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object215), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, signed short int __anonymous_object221);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object243), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, unsigned short int __anonymous_object249);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object271), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, signed int __anonymous_object277);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object299), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, unsigned int __anonymous_object305);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object327), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long int __anonymous_object333);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object355), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, signed long long int __anonymous_object361);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object383), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long int __anonymous_object389);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object411), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, unsigned long long int __anonymous_object417);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object439), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, float __anonymous_object445);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object467), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, double __anonymous_object473);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object495), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, long double __anonymous_object501);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object523), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, float _Complex __anonymous_object529);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object551), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, double _Complex __anonymous_object557);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object579), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, long double _Complex __anonymous_object585);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object607), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object635), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const void *__anonymous_object641);
 void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____operator_bitor__PFRd0_Rd0tVARGS2__FRd0_Rd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object642)(), void *__anonymous_object643, void *__anonymous_object644), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object645)(), void *__anonymous_object646, void *__anonymous_object647), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object648)(), void *__anonymous_object649, void *__anonymous_object650), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object651)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object652, void *__anonymous_object653), __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_object654, void *__anonymous_object655), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object657, void *__anonymous_object658), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object659), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype2tT__1)(void *__anonymous_object660, void *__anonymous_object661), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object664, _Bool __anonymous_object665), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object666), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object667, const char *__anonymous_object668), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object669), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object670, _Bool __anonymous_object671), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object673), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object676), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object677, const char *__anonymous_object678), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object679), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object680, const char *__anonymous_object681), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object684, const char *__anonymous_object685, unsigned long int __anonymous_object686), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object687, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype7tParams__1)(void *__anonymous_object688, void *__anonymous_object689), void *__os__R7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object692, _Bool __anonymous_object693), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object694), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object695, const char *__anonymous_object696), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object697), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object698, _Bool __anonymous_object699), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object700), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object701), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object703), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object704), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object705, const char *__anonymous_object706), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object707), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object708, const char *__anonymous_object709), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object712, const char *__anonymous_object713, unsigned long int __anonymous_object714), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object715, const char *__fmt__PCc_1, ...), void *__anonymous_object716, void *(*__anonymous_object717)(void *__anonymous_object718));
 void *__endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object720), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object721, _Bool __anonymous_object722), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object723), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object724, const char *__anonymous_object725), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object733), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object734, const char *__anonymous_object735), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object737, const char *__anonymous_object738), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object741, const char *__anonymous_object742, unsigned long int __anonymous_object743), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object744, const char *__fmt__PCc_1, ...), void *__anonymous_object745);
 void *__sep__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772);
 void *__sepTuple__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object775, _Bool __anonymous_object776), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object777), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object778, const char *__anonymous_object779), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object788, const char *__anonymous_object789), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object791, const char *__anonymous_object792), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object795, const char *__anonymous_object796, unsigned long int __anonymous_object797), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object798, const char *__fmt__PCc_1, ...), void *__anonymous_object799);
 void *__sepOn__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object801), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object802, _Bool __anonymous_object803), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object805, const char *__anonymous_object806), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object811), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object815, const char *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object821), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object822, const char *__anonymous_object823, unsigned long int __anonymous_object824), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object825, const char *__fmt__PCc_1, ...), void *__anonymous_object826);
 void *__sepOff__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object828), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object829, _Bool __anonymous_object830), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object832, const char *__anonymous_object833), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object838), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object842, const char *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object848), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object849, const char *__anonymous_object850, unsigned long int __anonymous_object851), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object852, const char *__fmt__PCc_1, ...), void *__anonymous_object853);
 void *__sepDisable__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object855), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object856, _Bool __anonymous_object857), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object859, const char *__anonymous_object860), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object862, _Bool __anonymous_object863), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object865), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object869, const char *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object875), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object876, const char *__anonymous_object877, unsigned long int __anonymous_object878), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object879, const char *__fmt__PCc_1, ...), void *__anonymous_object880);
 void *__sepEnable__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object882), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object883, _Bool __anonymous_object884), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object886, const char *__anonymous_object887), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object889, _Bool __anonymous_object890), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object896, const char *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object902), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object903, const char *__anonymous_object904, unsigned long int __anonymous_object905), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object906, const char *__fmt__PCc_1, ...), void *__anonymous_object907);
 void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____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_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object908)(), void *__anonymous_object909), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object910)(), void *__anonymous_object911, void *__anonymous_object912), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object913)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object914), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object915)(), void *__anonymous_object916, void *__anonymous_object917), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object918)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object919, void *__anonymous_object920), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object921)(), void *__anonymous_object922, void *__anonymous_object923), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object924)(), void *__anonymous_object925, void *__anonymous_object926), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object927)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object928, void *__anonymous_object929), __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_object930, void *__anonymous_object931), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object932), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object933, void *__anonymous_object934), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object935), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object936, void *__anonymous_object937), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object959), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object964, void *__anonymous_object965), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object969), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object970), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object971), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object974, void *__anonymous_object975), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object976), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
 void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____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_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object977)(), void *__anonymous_object978), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object979)(), void *__anonymous_object980, void *__anonymous_object981), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object982)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object983), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object984)(), void *__anonymous_object985, void *__anonymous_object986), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object987)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object988, void *__anonymous_object989), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object990)(), void *__anonymous_object991, void *__anonymous_object992), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object993)(), void *__anonymous_object994, void *__anonymous_object995), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object996)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object997, void *__anonymous_object998), __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_object999, void *__anonymous_object1000), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1002, void *__anonymous_object1003), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1004), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1005, void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1009, _Bool __anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1015, _Bool __anonymous_object1016), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1017), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1018), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1019), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1020), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1021), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1022, const char *__anonymous_object1023), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1024), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1025, const char *__anonymous_object1026), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1028), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1029, const char *__anonymous_object1030, unsigned long int __anonymous_object1031), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1032, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1033, void *__anonymous_object1034), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1035), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1038), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1039), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1040), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1043, void *__anonymous_object1044), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1045), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rb__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1046), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1047), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1048, char *__anonymous_object1049, unsigned long int __anonymous_object1050), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1051, char __anonymous_object1052), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1053, const char *__fmt__PCc_1, ...), void *__anonymous_object1054, _Bool *__anonymous_object1055);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1056), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1058, char *__anonymous_object1059, unsigned long int __anonymous_object1060), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1061, char __anonymous_object1062), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1063, const char *__fmt__PCc_1, ...), void *__anonymous_object1064, char *__anonymous_object1065);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1066), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1068, char *__anonymous_object1069, unsigned long int __anonymous_object1070), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1071, char __anonymous_object1072), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1073, const char *__fmt__PCc_1, ...), void *__anonymous_object1074, signed char *__anonymous_object1075);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1076), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1078, char *__anonymous_object1079, unsigned long int __anonymous_object1080), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1081, char __anonymous_object1082), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1083, const char *__fmt__PCc_1, ...), void *__anonymous_object1084, unsigned char *__anonymous_object1085);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1086), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1087), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1088, char *__anonymous_object1089, unsigned long int __anonymous_object1090), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1091, char __anonymous_object1092), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1093, const char *__fmt__PCc_1, ...), void *__anonymous_object1094, signed short int *__anonymous_object1095);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1097), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1098, char *__anonymous_object1099, unsigned long int __anonymous_object1100), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1101, char __anonymous_object1102), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1103, const char *__fmt__PCc_1, ...), void *__anonymous_object1104, unsigned short int *__anonymous_object1105);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1106), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1107), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1108, char *__anonymous_object1109, unsigned long int __anonymous_object1110), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1111, char __anonymous_object1112), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1113, const char *__fmt__PCc_1, ...), void *__anonymous_object1114, signed int *__anonymous_object1115);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1116), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1117), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1118, char *__anonymous_object1119, unsigned long int __anonymous_object1120), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1121, char __anonymous_object1122), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1123, const char *__fmt__PCc_1, ...), void *__anonymous_object1124, unsigned int *__anonymous_object1125);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1126), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1127), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1128, char *__anonymous_object1129, unsigned long int __anonymous_object1130), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1131, char __anonymous_object1132), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1133, const char *__fmt__PCc_1, ...), void *__anonymous_object1134, signed long int *__anonymous_object1135);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1136), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1137), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1138, char *__anonymous_object1139, unsigned long int __anonymous_object1140), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1141, char __anonymous_object1142), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1143, const char *__fmt__PCc_1, ...), void *__anonymous_object1144, signed long long int *__anonymous_object1145);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1146), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1147), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1148, char *__anonymous_object1149, unsigned long int __anonymous_object1150), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1151, char __anonymous_object1152), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1153, const char *__fmt__PCc_1, ...), void *__anonymous_object1154, unsigned long int *__anonymous_object1155);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1156), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1157), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1158, char *__anonymous_object1159, unsigned long int __anonymous_object1160), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1161, char __anonymous_object1162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1163, const char *__fmt__PCc_1, ...), void *__anonymous_object1164, unsigned long long int *__anonymous_object1165);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1166), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1167), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1168, char *__anonymous_object1169, unsigned long int __anonymous_object1170), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1171, char __anonymous_object1172), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1173, const char *__fmt__PCc_1, ...), void *__anonymous_object1174, float *__anonymous_object1175);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1176), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1177), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1178, char *__anonymous_object1179, unsigned long int __anonymous_object1180), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1181, char __anonymous_object1182), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1183, const char *__fmt__PCc_1, ...), void *__anonymous_object1184, double *__anonymous_object1185);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1186), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1187), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1188, char *__anonymous_object1189, unsigned long int __anonymous_object1190), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1191, char __anonymous_object1192), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1193, const char *__fmt__PCc_1, ...), void *__anonymous_object1194, long double *__anonymous_object1195);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1196), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1197), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1198, char *__anonymous_object1199, unsigned long int __anonymous_object1200), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1201, char __anonymous_object1202), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1203, const char *__fmt__PCc_1, ...), void *__anonymous_object1204, float _Complex *__anonymous_object1205);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1206), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1207), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1208, char *__anonymous_object1209, unsigned long int __anonymous_object1210), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1211, char __anonymous_object1212), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1213, const char *__fmt__PCc_1, ...), void *__anonymous_object1214, double _Complex *__anonymous_object1215);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1216), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1217), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1218, char *__anonymous_object1219, unsigned long int __anonymous_object1220), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1221, char __anonymous_object1222), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1223, const char *__fmt__PCc_1, ...), void *__anonymous_object1224, long double _Complex *__anonymous_object1225);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1226), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1227), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1228, char *__anonymous_object1229, unsigned long int __anonymous_object1230), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1231, char __anonymous_object1232), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1233, const char *__fmt__PCc_1, ...), void *__anonymous_object1234, void *(*__anonymous_object1235)(void *__anonymous_object1236));
 void *__endl__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1237), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1238), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1239, char *__anonymous_object1240, unsigned long int __anonymous_object1241), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1242, char __anonymous_object1243), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1244, const char *__fmt__PCc_1, ...), void *__is__R7tistype_1);
+void __for_each__A0_2_0_0____operator_assign__Fd0_d0d0____constructor__F_d0____constructor__F_d0d0____destructor__F_d0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_preincr__Fd0_d0____operator_predecr__Fd0_d0____operator_equal__Fi_d0d0____operator_notequal__Fi_d0d0____operator_deref__Fd1_d0__F_d0d0F_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__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__F_9telt_type__1)(void *__anonymous_object40));
+void __for_each_reverse__A0_2_0_0____operator_assign__Fd0_d0d0____constructor__F_d0____constructor__F_d0d0____destructor__F_d0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_preincr__Fd0_d0____operator_predecr__Fd0_d0____operator_equal__Fi_d0d0____operator_notequal__Fi_d0d0____operator_deref__Fd1_d0__F_d0d0F_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__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__F_9telt_type__1)(void *__anonymous_object81));
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0b__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object103), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, _Bool __anonymous_object109);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0c__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object131), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, char __anonymous_object137);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Sc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object159), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, signed char __anonymous_object165);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Uc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object187), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, unsigned char __anonymous_object193);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0s__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object215), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, signed short int __anonymous_object221);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Us__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object243), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, unsigned short int __anonymous_object249);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object271), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, signed int __anonymous_object277);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Ui__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object299), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, unsigned int __anonymous_object305);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object327), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long int __anonymous_object333);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object355), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, signed long long int __anonymous_object361);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Ul__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object383), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long int __anonymous_object389);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object411), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, unsigned long long int __anonymous_object417);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object439), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, float __anonymous_object445);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object467), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, double __anonymous_object473);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object495), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, long double __anonymous_object501);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object523), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, float _Complex __anonymous_object529);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object551), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, double _Complex __anonymous_object557);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object579), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, long double _Complex __anonymous_object585);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object607), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object635), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const void *__anonymous_object641);
+void *___operator_bitor__A0_2_0_1____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_bitor__Fd0_d0tVARGS2__Fd0_d0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object642)(), void *__anonymous_object643, void *__anonymous_object644), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object645)(), void *__anonymous_object646, void *__anonymous_object647), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object648)(), void *__anonymous_object649, void *__anonymous_object650), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object651)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object652, void *__anonymous_object653), __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__F2tT_2tT2tT__1)(void *__anonymous_object654, void *__anonymous_object655), __attribute__ ((unused)) void (*___constructor__F_2tT__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*___constructor__F_2tT2tT__1)(void *__anonymous_object657, void *__anonymous_object658), __attribute__ ((unused)) void (*___destructor__F_2tT__1)(void *__anonymous_object659), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype2tT__1)(void *__anonymous_object660, void *__anonymous_object661), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object664, _Bool __anonymous_object665), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object666), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object667, const char *__anonymous_object668), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object669), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object670, _Bool __anonymous_object671), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object673), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object676), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object677, const char *__anonymous_object678), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object679), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object680, const char *__anonymous_object681), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object684, const char *__anonymous_object685, unsigned long int __anonymous_object686), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object687, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype7tParams__1)(void *__anonymous_object688, void *__anonymous_object689), void *__os__7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object692, _Bool __anonymous_object693), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object694), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object695, const char *__anonymous_object696), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object697), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object698, _Bool __anonymous_object699), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object700), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object701), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object703), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object704), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object705, const char *__anonymous_object706), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object707), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object708, const char *__anonymous_object709), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object712, const char *__anonymous_object713, unsigned long int __anonymous_object714), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object715, const char *__fmt__PCc_1, ...), void *__anonymous_object716, void *(*__anonymous_object717)(void *__anonymous_object718));
+void *__endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object720), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object721, _Bool __anonymous_object722), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object723), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object724, const char *__anonymous_object725), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object733), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object734, const char *__anonymous_object735), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object737, const char *__anonymous_object738), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object741, const char *__anonymous_object742, unsigned long int __anonymous_object743), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object744, const char *__fmt__PCc_1, ...), void *__anonymous_object745);
+void *__sep__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772);
+void *__sepTuple__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object775, _Bool __anonymous_object776), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object777), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object778, const char *__anonymous_object779), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object788, const char *__anonymous_object789), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object791, const char *__anonymous_object792), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object795, const char *__anonymous_object796, unsigned long int __anonymous_object797), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object798, const char *__fmt__PCc_1, ...), void *__anonymous_object799);
+void *__sepOn__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object801), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object802, _Bool __anonymous_object803), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object805, const char *__anonymous_object806), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object811), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object815, const char *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object821), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object822, const char *__anonymous_object823, unsigned long int __anonymous_object824), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object825, const char *__fmt__PCc_1, ...), void *__anonymous_object826);
+void *__sepOff__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object828), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object829, _Bool __anonymous_object830), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object832, const char *__anonymous_object833), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object838), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object842, const char *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object848), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object849, const char *__anonymous_object850, unsigned long int __anonymous_object851), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object852, const char *__fmt__PCc_1, ...), void *__anonymous_object853);
+void *__sepDisable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object855), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object856, _Bool __anonymous_object857), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object859, const char *__anonymous_object860), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object862, _Bool __anonymous_object863), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object865), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object869, const char *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object875), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object876, const char *__anonymous_object877, unsigned long int __anonymous_object878), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object879, const char *__fmt__PCc_1, ...), void *__anonymous_object880);
+void *__sepEnable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object882), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object883, _Bool __anonymous_object884), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object886, const char *__anonymous_object887), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object889, _Bool __anonymous_object890), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object896, const char *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object902), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object903, const char *__anonymous_object904, unsigned long int __anonymous_object905), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object906, const char *__fmt__PCc_1, ...), void *__anonymous_object907);
+void __write__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object908)(), void *__anonymous_object909), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object910)(), void *__anonymous_object911, void *__anonymous_object912), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object913)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object914), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object915)(), void *__anonymous_object916, void *__anonymous_object917), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object918)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object919, void *__anonymous_object920), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object921)(), void *__anonymous_object922, void *__anonymous_object923), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object924)(), void *__anonymous_object925, void *__anonymous_object926), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object927)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object928, void *__anonymous_object929), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object930, void *__anonymous_object931), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object932), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object933, void *__anonymous_object934), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object935), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object936, void *__anonymous_object937), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object959), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object964, void *__anonymous_object965), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object969), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object970), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object971), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object974, void *__anonymous_object975), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object976), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);
+void __write_reverse__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object977)(), void *__anonymous_object978), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object979)(), void *__anonymous_object980, void *__anonymous_object981), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object982)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object983), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object984)(), void *__anonymous_object985, void *__anonymous_object986), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object987)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object988, void *__anonymous_object989), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object990)(), void *__anonymous_object991, void *__anonymous_object992), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object993)(), void *__anonymous_object994, void *__anonymous_object995), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object996)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object997, void *__anonymous_object998), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object999, void *__anonymous_object1000), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object1002, void *__anonymous_object1003), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object1004), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object1005, void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1009, _Bool __anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1015, _Bool __anonymous_object1016), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1017), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1018), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1019), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1020), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1021), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1022, const char *__anonymous_object1023), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1024), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1025, const char *__anonymous_object1026), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1028), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1029, const char *__anonymous_object1030, unsigned long int __anonymous_object1031), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1032, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object1033, void *__anonymous_object1034), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object1035), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object1038), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1039), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1040), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1043, void *__anonymous_object1044), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object1045), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0b__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1046), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1047), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1048, char *__anonymous_object1049, unsigned long int __anonymous_object1050), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1051, char __anonymous_object1052), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1053, const char *__fmt__PCc_1, ...), void *__anonymous_object1054, _Bool *__anonymous_object1055);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0c__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1056), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1058, char *__anonymous_object1059, unsigned long int __anonymous_object1060), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1061, char __anonymous_object1062), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1063, const char *__fmt__PCc_1, ...), void *__anonymous_object1064, char *__anonymous_object1065);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Sc__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1066), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1068, char *__anonymous_object1069, unsigned long int __anonymous_object1070), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1071, char __anonymous_object1072), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1073, const char *__fmt__PCc_1, ...), void *__anonymous_object1074, signed char *__anonymous_object1075);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Uc__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1076), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1078, char *__anonymous_object1079, unsigned long int __anonymous_object1080), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1081, char __anonymous_object1082), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1083, const char *__fmt__PCc_1, ...), void *__anonymous_object1084, unsigned char *__anonymous_object1085);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0s__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1086), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1087), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1088, char *__anonymous_object1089, unsigned long int __anonymous_object1090), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1091, char __anonymous_object1092), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1093, const char *__fmt__PCc_1, ...), void *__anonymous_object1094, signed short int *__anonymous_object1095);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Us__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1097), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1098, char *__anonymous_object1099, unsigned long int __anonymous_object1100), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1101, char __anonymous_object1102), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1103, const char *__fmt__PCc_1, ...), void *__anonymous_object1104, unsigned short int *__anonymous_object1105);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0i__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1106), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1107), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1108, char *__anonymous_object1109, unsigned long int __anonymous_object1110), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1111, char __anonymous_object1112), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1113, const char *__fmt__PCc_1, ...), void *__anonymous_object1114, signed int *__anonymous_object1115);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Ui__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1116), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1117), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1118, char *__anonymous_object1119, unsigned long int __anonymous_object1120), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1121, char __anonymous_object1122), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1123, const char *__fmt__PCc_1, ...), void *__anonymous_object1124, unsigned int *__anonymous_object1125);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0l__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1126), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1127), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1128, char *__anonymous_object1129, unsigned long int __anonymous_object1130), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1131, char __anonymous_object1132), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1133, const char *__fmt__PCc_1, ...), void *__anonymous_object1134, signed long int *__anonymous_object1135);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0q__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1136), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1137), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1138, char *__anonymous_object1139, unsigned long int __anonymous_object1140), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1141, char __anonymous_object1142), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1143, const char *__fmt__PCc_1, ...), void *__anonymous_object1144, signed long long int *__anonymous_object1145);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Ul__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1146), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1147), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1148, char *__anonymous_object1149, unsigned long int __anonymous_object1150), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1151, char __anonymous_object1152), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1153, const char *__fmt__PCc_1, ...), void *__anonymous_object1154, unsigned long int *__anonymous_object1155);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Uq__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1156), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1157), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1158, char *__anonymous_object1159, unsigned long int __anonymous_object1160), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1161, char __anonymous_object1162), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1163, const char *__fmt__PCc_1, ...), void *__anonymous_object1164, unsigned long long int *__anonymous_object1165);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0f__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1166), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1167), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1168, char *__anonymous_object1169, unsigned long int __anonymous_object1170), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1171, char __anonymous_object1172), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1173, const char *__fmt__PCc_1, ...), void *__anonymous_object1174, float *__anonymous_object1175);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0d__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1176), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1177), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1178, char *__anonymous_object1179, unsigned long int __anonymous_object1180), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1181, char __anonymous_object1182), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1183, const char *__fmt__PCc_1, ...), void *__anonymous_object1184, double *__anonymous_object1185);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0r__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1186), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1187), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1188, char *__anonymous_object1189, unsigned long int __anonymous_object1190), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1191, char __anonymous_object1192), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1193, const char *__fmt__PCc_1, ...), void *__anonymous_object1194, long double *__anonymous_object1195);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Xf__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1196), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1197), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1198, char *__anonymous_object1199, unsigned long int __anonymous_object1200), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1201, char __anonymous_object1202), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1203, const char *__fmt__PCc_1, ...), void *__anonymous_object1204, float _Complex *__anonymous_object1205);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Xd__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1206), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1207), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1208, char *__anonymous_object1209, unsigned long int __anonymous_object1210), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1211, char __anonymous_object1212), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1213, const char *__fmt__PCc_1, ...), void *__anonymous_object1214, double _Complex *__anonymous_object1215);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Xr__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1216), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1217), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1218, char *__anonymous_object1219, unsigned long int __anonymous_object1220), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1221, char __anonymous_object1222), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1223, const char *__fmt__PCc_1, ...), void *__anonymous_object1224, long double _Complex *__anonymous_object1225);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1226), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1227), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1228, char *__anonymous_object1229, unsigned long int __anonymous_object1230), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1231, char __anonymous_object1232), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1233, const char *__fmt__PCc_1, ...), void *__anonymous_object1234, void *(*__anonymous_object1235)(void *__anonymous_object1236));
+void *__endl__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1237), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1238), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1239, char *__anonymous_object1240, unsigned long int __anonymous_object1241), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1242, char __anonymous_object1243), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1244, const char *__fmt__PCc_1, ...), void *__is__7tistype_1);
 struct _Istream_cstrUC {
     char *__s__Pc_1;
 };
 static inline void ___constructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1);
 static inline void ___constructor__F_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 ___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) /* ?{} */);
+}
 static inline void ___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1) /* ?{} */);
+}
 static inline void ___destructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_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_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___destructor__F_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1);
+static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, char *__s__Pc_1);
+static inline void ___constructor__F_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1) /* ?{} */);
+}
+static inline void ___constructor__F_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1) /* ?{} */);
+}
+static inline void ___destructor__F_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1) /* ^?{} */);
+}
+static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_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), (*___dst__R16s_Istream_cstrUC_1)));
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
+    ((void)___constructor__F_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), (*___dst__16s_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){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+static inline void ___constructor__F_16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, char *__s__Pc_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+}
 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1245);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1246), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1247), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1248, char *__anonymous_object1249, unsigned long int __anonymous_object1250), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1251, char __anonymous_object1252), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1253, const char *__fmt__PCc_1, ...), void *__anonymous_object1254, struct _Istream_cstrUC __anonymous_object1255);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1246), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1247), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1248, char *__anonymous_object1249, unsigned long int __anonymous_object1250), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1251, char __anonymous_object1252), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1253, const char *__fmt__PCc_1, ...), void *__anonymous_object1254, struct _Istream_cstrUC __anonymous_object1255);
 struct _Istream_cstrC {
     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);
 static inline void ___constructor__F_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 ___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).__size__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_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) /* ?{} */);
+}
 static inline void ___destructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1){
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1) /* ^?{} */);
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_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_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1);
+static inline void ___constructor__F_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___destructor__F_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1);
+static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___constructor__F_15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1);
+static inline void ___constructor__F_15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1);
+static inline void ___constructor__F_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1) /* ^?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1) /* ^?{} */);
+}
+static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1){
     struct _Istream_cstrC ___ret__15s_Istream_cstrC_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), (*___dst__R15s_Istream_cstrC_1)));
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1));
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
+    ((void)___constructor__F_15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), (*___dst__15s_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)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_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){
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */);
+static inline void ___constructor__F_15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */);
+}
 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1256, signed int __size__i_1);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1257), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1258), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1259, char *__anonymous_object1260, unsigned long int __anonymous_object1261), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1262, char __anonymous_object1263), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1264, const char *__fmt__PCc_1, ...), void *__anonymous_object1265, struct _Istream_cstrC __anonymous_object1266);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1257), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1258), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1259, char *__anonymous_object1260, unsigned long int __anonymous_object1261), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1262, char __anonymous_object1263), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1264, const char *__fmt__PCc_1, ...), void *__anonymous_object1265, struct _Istream_cstrC __anonymous_object1266);
 struct Duration {
     signed long int __tv__l_1;
 };
 static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
 static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
 static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
 static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
 static inline void ___constructor__F_R9sDurationl_autogen___1(struct Duration *___dst__R9sDuration_1, signed long int __tv__l_1);
 static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     ((void)((*___dst__R9sDuration_1).__tv__l_1) /* ?{} */);
+}
 static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
     ((void)((*___dst__R9sDuration_1).__tv__l_1=___src__9sDuration_1.__tv__l_1) /* ?{} */);
+}
 static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     ((void)((*___dst__R9sDuration_1).__tv__l_1) /* ^?{} */);
+}
 static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
+static inline void ___constructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1);
+static inline void ___constructor__F_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1);
+static inline void ___destructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1);
+static inline struct Duration ___operator_assign__F9sDuration_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1);
+static inline void ___constructor__F_9sDurationl_autogen___1(struct Duration *___dst__9sDuration_1, signed long int __tv__l_1);
+static inline void ___constructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1){
+    ((void)((*___dst__9sDuration_1).__tv__l_1) /* ?{} */);
+}
+static inline void ___constructor__F_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1){
+    ((void)((*___dst__9sDuration_1).__tv__l_1=___src__9sDuration_1.__tv__l_1) /* ?{} */);
+}
+static inline void ___destructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1){
+    ((void)((*___dst__9sDuration_1).__tv__l_1) /* ^?{} */);
+}
+static inline struct Duration ___operator_assign__F9sDuration_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1){
     struct Duration ___ret__9sDuration_1;
     ((void)((*___dst__R9sDuration_1).__tv__l_1=___src__9sDuration_1.__tv__l_1));
     ((void)___constructor__F_R9sDuration9sDuration_autogen___1((&___ret__9sDuration_1), (*___dst__R9sDuration_1)));
+    ((void)((*___dst__9sDuration_1).__tv__l_1=___src__9sDuration_1.__tv__l_1));
+    ((void)___constructor__F_9sDuration9sDuration_autogen___1((&___ret__9sDuration_1), (*___dst__9sDuration_1)));
     return ___ret__9sDuration_1;
+}
 static inline void ___constructor__F_R9sDurationl_autogen___1(struct Duration *___dst__R9sDuration_1, signed long int __tv__l_1){
     ((void)((*___dst__R9sDuration_1).__tv__l_1=__tv__l_1) /* ?{} */);
+}
 static inline void ___constructor__F_R9sDuration__1(struct Duration *__dur__R9sDuration_1){
     ((void)((*__dur__R9sDuration_1).__tv__l_1) /* ?{} */);
     ((void)((*__dur__R9sDuration_1).__tv__l_1=((signed long int )0)));
+}
 static inline void ___constructor__F_R9sDurationZ__1(struct Duration *__dur__R9sDuration_1, long int __anonymous_object1267){
     ((void)((*__dur__R9sDuration_1).__tv__l_1) /* ?{} */);
     ((void)((*__dur__R9sDuration_1).__tv__l_1=((signed long int )0)));
+static inline void ___constructor__F_9sDurationl_autogen___1(struct Duration *___dst__9sDuration_1, signed long int __tv__l_1){
+    ((void)((*___dst__9sDuration_1).__tv__l_1=__tv__l_1) /* ?{} */);
+}
+static inline void ___constructor__F_9sDuration__1(struct Duration *__dur__9sDuration_1){
+    ((void)((*__dur__9sDuration_1).__tv__l_1) /* ?{} */);
+    ((void)((*__dur__9sDuration_1).__tv__l_1=((signed long int )0)));
+}
+static inline void ___constructor__F_9sDurationZ__1(struct Duration *__dur__9sDuration_1, long int __anonymous_object1267){
+    ((void)((*__dur__9sDuration_1).__tv__l_1) /* ?{} */);
+    ((void)((*__dur__9sDuration_1).__tv__l_1=((signed long int )0)));
+}
 struct Time {
     unsigned long int __tv__Ul_1;
 };
 static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
 static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
 static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
 static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
 static inline void ___constructor__F_R5sTimeUl_autogen___1(struct Time *___dst__R5sTime_1, unsigned long int __tv__Ul_1);
 static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     ((void)((*___dst__R5sTime_1).__tv__Ul_1) /* ?{} */);
+}
 static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
     ((void)((*___dst__R5sTime_1).__tv__Ul_1=___src__5sTime_1.__tv__Ul_1) /* ?{} */);
+}
 static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     ((void)((*___dst__R5sTime_1).__tv__Ul_1) /* ^?{} */);
+}
 static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
+static inline void ___constructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1);
+static inline void ___constructor__F_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1);
+static inline void ___destructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1);
+static inline struct Time ___operator_assign__F5sTime_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1);
+static inline void ___constructor__F_5sTimeUl_autogen___1(struct Time *___dst__5sTime_1, unsigned long int __tv__Ul_1);
+static inline void ___constructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1){
+    ((void)((*___dst__5sTime_1).__tv__Ul_1) /* ?{} */);
+}
+static inline void ___constructor__F_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1){
+    ((void)((*___dst__5sTime_1).__tv__Ul_1=___src__5sTime_1.__tv__Ul_1) /* ?{} */);
+}
+static inline void ___destructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1){
+    ((void)((*___dst__5sTime_1).__tv__Ul_1) /* ^?{} */);
+}
+static inline struct Time ___operator_assign__F5sTime_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1){
     struct Time ___ret__5sTime_1;
     ((void)((*___dst__R5sTime_1).__tv__Ul_1=___src__5sTime_1.__tv__Ul_1));
     ((void)___constructor__F_R5sTime5sTime_autogen___1((&___ret__5sTime_1), (*___dst__R5sTime_1)));
+    ((void)((*___dst__5sTime_1).__tv__Ul_1=___src__5sTime_1.__tv__Ul_1));
+    ((void)___constructor__F_5sTime5sTime_autogen___1((&___ret__5sTime_1), (*___dst__5sTime_1)));
     return ___ret__5sTime_1;
+}
 static inline void ___constructor__F_R5sTimeUl_autogen___1(struct Time *___dst__R5sTime_1, unsigned long int __tv__Ul_1){
     ((void)((*___dst__R5sTime_1).__tv__Ul_1=__tv__Ul_1) /* ?{} */);
+}
 static inline void ___constructor__F_R5sTime__1(struct Time *__time__R5sTime_1){
     ((void)((*__time__R5sTime_1).__tv__Ul_1) /* ?{} */);
     ((void)((*__time__R5sTime_1).__tv__Ul_1=((unsigned long int )0)));
+}
 static inline void ___constructor__F_R5sTimeZ__1(struct Time *__time__R5sTime_1, long int __anonymous_object1268){
     ((void)((*__time__R5sTime_1).__tv__Ul_1) /* ?{} */);
     ((void)((*__time__R5sTime_1).__tv__Ul_1=((unsigned long int )0)));
+}
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd09sDuration__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1269), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1270), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1271, _Bool __anonymous_object1272), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1273), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1274, const char *__anonymous_object1275), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1276), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1277, _Bool __anonymous_object1278), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1279), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1280), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1281), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1282), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1283), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1284, const char *__anonymous_object1285), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1286), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1287, const char *__anonymous_object1288), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1289), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1290), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1291, const char *__anonymous_object1292, unsigned long int __anonymous_object1293), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1294, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Duration __dur__9sDuration_1);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd05sTime__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1295), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1296), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1297, _Bool __anonymous_object1298), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1299), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1300, const char *__anonymous_object1301), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1302), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1303, _Bool __anonymous_object1304), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1305), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1306), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1307), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1308), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1309), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1310, const char *__anonymous_object1311), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1312), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1313, const char *__anonymous_object1314), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1315), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1316), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1317, const char *__anonymous_object1318, unsigned long int __anonymous_object1319), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1320, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Time __time__5sTime_1);
+static inline void ___constructor__F_5sTimeUl_autogen___1(struct Time *___dst__5sTime_1, unsigned long int __tv__Ul_1){
+    ((void)((*___dst__5sTime_1).__tv__Ul_1=__tv__Ul_1) /* ?{} */);
+}
+static inline void ___constructor__F_5sTime__1(struct Time *__time__5sTime_1){
+    ((void)((*__time__5sTime_1).__tv__Ul_1) /* ?{} */);
+    ((void)((*__time__5sTime_1).__tv__Ul_1=((unsigned long int )0)));
+}
+static inline void ___constructor__F_5sTimeZ__1(struct Time *__time__5sTime_1, long int __anonymous_object1268){
+    ((void)((*__time__5sTime_1).__tv__Ul_1) /* ?{} */);
+    ((void)((*__time__5sTime_1).__tv__Ul_1=((unsigned long int )0)));
+}
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d09sDuration__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1269), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1270), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1271, _Bool __anonymous_object1272), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1273), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1274, const char *__anonymous_object1275), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1276), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1277, _Bool __anonymous_object1278), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1279), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1280), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1281), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1282), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1283), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1284, const char *__anonymous_object1285), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1286), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1287, const char *__anonymous_object1288), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1289), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1290), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1291, const char *__anonymous_object1292, unsigned long int __anonymous_object1293), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1294, const char *__fmt__PCc_1, ...), void *__os__7tostype_1, struct Duration __dur__9sDuration_1);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d05sTime__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1295), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1296), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1297, _Bool __anonymous_object1298), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1299), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1300, const char *__anonymous_object1301), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1302), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1303, _Bool __anonymous_object1304), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1305), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1306), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1307), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1308), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1309), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1310, const char *__anonymous_object1311), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1312), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1313, const char *__anonymous_object1314), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1315), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1316), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1317, const char *__anonymous_object1318, unsigned long int __anonymous_object1319), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1320, const char *__fmt__PCc_1, ...), void *__os__7tostype_1, struct Time __time__5sTime_1);
 enum __anonymous0 {
     __sepSize__C13e__anonymous0_1 = 16,
 …
     char __tupleSeparator__A0c_1[((unsigned long int )__sepSize__C13e__anonymous0_1)];
 };
 static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
 static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1);
 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).__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+static inline void ___constructor__F_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1);
+static inline void ___constructor__F_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___destructor__F_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1);
+static inline struct ofstream ___operator_assign__F9sofstream_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___constructor__F_9sofstreamPv_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_9sofstreamPvb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1);
+static inline void ___constructor__F_9sofstreamPvbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1);
+static inline void ___constructor__F_9sofstreamPvbbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1);
+static inline void ___constructor__F_9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__9sofstream_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_9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__9sofstream_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_9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__9sofstream_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_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index0 = 0;
         for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index0)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index0)]) /* ?{} */);
+        }
 …
         signed int _index1 = 0;
         for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
             ((void)((*___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).__file__Pv_1=___src__9sofstream_1.__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index1)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=___src__9sofstream_1.__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index2 = 0;
         for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index2)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index2)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index2)]) /* ?{} */);
+        }
 …
         signed int _index3 = 0;
         for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
             ((void)((*___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){
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index3)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index3)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___destructor__F_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1){
+    {
         signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index4>=0);((void)(--_index4))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)]) /* ^?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index4)]) /* ^?{} */);
+        }
 …
         signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index5>=0);((void)(--_index5))) {
             ((void)((*___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).__sepOnOff__b_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__file__Pv_1) /* ^?{} */);
+}
 static inline struct ofstream ___operator_assign__F9sofstream_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index5)]) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__file__Pv_1) /* ^?{} */);
+}
+static inline struct ofstream ___operator_assign__F9sofstream_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1){
     struct ofstream ___ret__9sofstream_1;
     ((void)((*___dst__R9sofstream_1).__file__Pv_1=___src__9sofstream_1.__file__Pv_1));
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1));
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1));
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1));
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=___src__9sofstream_1.__file__Pv_1));
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1));
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1));
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1));
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    {
         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)]));
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index6)]=___src__9sofstream_1.__separator__A0c_1[((signed long int )_index6)]));
+        }
 …
         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), (*___dst__R9sofstream_1)));
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index7)]=___src__9sofstream_1.__tupleSeparator__A0c_1[((signed long int )_index7)]));
+        }
+    }
+    ((void)___constructor__F_9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), (*___dst__9sofstream_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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+static inline void ___constructor__F_9sofstreamPv_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index8 = 0;
         for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index8)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index8)]) /* ?{} */);
+        }
 …
         signed int _index9 = 0;
         for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index9)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index10 = 0;
         for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index10)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index10)]) /* ?{} */);
+        }
 …
         signed int _index11 = 0;
         for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index11)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index12 = 0;
         for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index12)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index12)]) /* ?{} */);
+        }
 …
         signed int _index13 = 0;
         for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index13)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index14 = 0;
         for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index14)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index14)]) /* ?{} */);
+        }
 …
         signed int _index15 = 0;
         for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index15)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index16 = 0;
         for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index16)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index16)]) /* ?{} */);
+        }
 …
         signed int _index17 = 0;
         for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index17)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__9sofstream_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__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index18 = 0;
         for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index18)]=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index18)]=__separator__A0c_1[((signed long int )_index18)]) /* ?{} */);
+        }
 …
         signed int _index19 = 0;
         for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index19)]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__9sofstream_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__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index20 = 0;
         for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[((signed long int )_index20)]=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[((signed long int )_index20)]=__separator__A0c_1[((signed long int )_index20)]) /* ?{} */);
+        }
 …
         signed int _index21 = 0;
         for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)]=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
+        }
+    }
+}
 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1321);
 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1322);
 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1323, _Bool __anonymous_object1324);
 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1325);
 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1326, const char *__anonymous_object1327);
 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1328);
 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1329, _Bool __anonymous_object1330);
 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1331);
 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1332);
 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1333);
 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1334);
 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1335);
 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1336, const char *__anonymous_object1337);
 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1338);
 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1339, const char *__anonymous_object1340);
 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1341);
 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1342);
 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1343, const char *__name__PCc_1, const char *__mode__PCc_1);
 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1);
 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1345);
 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1346, const char *__data__PCc_1, unsigned long int __size__Ul_1);
 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1347, const char *__fmt__PCc_1, ...);
 void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1);
 void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
 void ___constructor__F_R9sofstreamPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1);
 extern struct ofstream *__sout__R9sofstream_1;
 extern struct ofstream *__serr__R9sofstream_1;
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[((signed long int )_index21)]=__tupleSeparator__A0c_1[((signed long int )_index21)]) /* ?{} */);
+        }
+    }
+}
+_Bool __sepPrt__Fb_9sofstream__1(struct ofstream *__anonymous_object1321);
+void __sepReset__F_9sofstream__1(struct ofstream *__anonymous_object1322);
+void __sepReset__F_9sofstreamb__1(struct ofstream *__anonymous_object1323, _Bool __anonymous_object1324);
+const char *__sepGetCur__FPCc_9sofstream__1(struct ofstream *__anonymous_object1325);
+void __sepSetCur__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1326, const char *__anonymous_object1327);
+_Bool __getNL__Fb_9sofstream__1(struct ofstream *__anonymous_object1328);
+void __setNL__F_9sofstreamb__1(struct ofstream *__anonymous_object1329, _Bool __anonymous_object1330);
+void __sepOn__F_9sofstream__1(struct ofstream *__anonymous_object1331);
+void __sepOff__F_9sofstream__1(struct ofstream *__anonymous_object1332);
+_Bool __sepDisable__Fb_9sofstream__1(struct ofstream *__anonymous_object1333);
+_Bool __sepEnable__Fb_9sofstream__1(struct ofstream *__anonymous_object1334);
+const char *__sepGet__FPCc_9sofstream__1(struct ofstream *__anonymous_object1335);
+void __sepSet__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1336, const char *__anonymous_object1337);
+const char *__sepGetTuple__FPCc_9sofstream__1(struct ofstream *__anonymous_object1338);
+void __sepSetTuple__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1339, const char *__anonymous_object1340);
+signed int __fail__Fi_9sofstream__1(struct ofstream *__anonymous_object1341);
+signed int __flush__Fi_9sofstream__1(struct ofstream *__anonymous_object1342);
+void __open__F_9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1343, const char *__name__PCc_1, const char *__mode__PCc_1);
+void __open__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1);
+void __close__F_9sofstream__1(struct ofstream *__anonymous_object1345);
+struct ofstream *__write__F9sofstream_9sofstreamPCcUl__1(struct ofstream *__anonymous_object1346, const char *__data__PCc_1, unsigned long int __size__Ul_1);
+signed int __fmt__Fi_9sofstreamPCc__1(struct ofstream *__anonymous_object1347, const char *__fmt__PCc_1, ...);
+void ___constructor__F_9sofstream__1(struct ofstream *__os__9sofstream_1);
+void ___constructor__F_9sofstreamPCcPCc__1(struct ofstream *__os__9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
+void ___constructor__F_9sofstreamPCc__1(struct ofstream *__os__9sofstream_1, const char *__name__PCc_1);
+extern struct ofstream *__sout__9sofstream_1;
+extern struct ofstream *__serr__9sofstream_1;
 struct ifstream {
     void *__file__Pv_1;
 };
 static inline void ___constructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1);
 static inline void ___constructor__F_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1);
 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) /* ?{} */);
+}
 static inline void ___constructor__F_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1) /* ?{} */);
+}
 static inline void ___destructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_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_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1);
+static inline void ___constructor__F_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___destructor__F_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1);
+static inline struct ifstream ___operator_assign__F9sifstream_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___constructor__F_9sifstreamPv_autogen___1(struct ifstream *___dst__9sifstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1) /* ?{} */);
+}
+static inline void ___constructor__F_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1) /* ?{} */);
+}
+static inline void ___destructor__F_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1) /* ^?{} */);
+}
+static inline struct ifstream ___operator_assign__F9sifstream_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_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), (*___dst__R9sifstream_1)));
+    ((void)((*___dst__9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
+    ((void)___constructor__F_9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), (*___dst__9sifstream_1)));
     return ___ret__9sifstream_1;
+}
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+}
 signed int __fail__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 signed int __eof__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 void __open__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
 void __open__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
 void __close__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
 struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1);
 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1348, const char *__fmt__PCc_1, ...);
 void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
 void ___constructor__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
 extern struct ifstream *__sin__R9sifstream_1;
+static inline void ___constructor__F_9sifstreamPv_autogen___1(struct ifstream *___dst__9sifstream_1, void *__file__Pv_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+}
+signed int __fail__Fi_9sifstream__1(struct ifstream *__is__9sifstream_1);
+signed int __eof__Fi_9sifstream__1(struct ifstream *__is__9sifstream_1);
+void __open__F_9sifstreamPCcPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
+void __open__F_9sifstreamPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1);
+void __close__F_9sifstream__1(struct ifstream *__is__9sifstream_1);
+struct ifstream *__read__F9sifstream_9sifstreamPcUl__1(struct ifstream *__is__9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
+struct ifstream *__ungetc__F9sifstream_9sifstreamc__1(struct ifstream *__is__9sifstream_1, char __c__c_1);
+signed int __fmt__Fi_9sifstreamPCc__1(struct ifstream *__anonymous_object1348, const char *__fmt__PCc_1, ...);
+void ___constructor__F_9sifstream__1(struct ifstream *__is__9sifstream_1);
+void ___constructor__F_9sifstreamPCcPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
+void ___constructor__F_9sifstreamPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1);
+extern struct ifstream *__sin__9sifstream_1;
 void __f__F_c__1(char __v__c_1){
     struct ofstream *_tmp_cp_ret2;
 …
     struct ofstream *_tmp_cp_ret4;
     __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1349))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1350))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1351, _Bool __anonymous_object1352))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1353))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1354, const char *__anonymous_object1355))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1356))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1357, _Bool __anonymous_object1358))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1359))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1360))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1363))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1364, const char *__anonymous_object1365))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1366))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1367, const char *__anonymous_object1368))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1369))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1370))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1371, const char *__anonymous_object1372, unsigned long int __anonymous_object1373))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1374, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1375))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1376))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1377, _Bool __anonymous_object1378))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1379))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1380, const char *__anonymous_object1381))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1382))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1383, _Bool __anonymous_object1384))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1385))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1386))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1389))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1390, const char *__anonymous_object1391))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1392))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1393, const char *__anonymous_object1394))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1395))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1396))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1397, const char *__anonymous_object1398, unsigned long int __anonymous_object1399))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1400, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1401))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1402))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1403, _Bool __anonymous_object1404))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1405))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1406, const char *__anonymous_object1407))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1408))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1409, _Bool __anonymous_object1410))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1411))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1412))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1415))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1416, const char *__anonymous_object1417))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1418))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1419, const char *__anonymous_object1420))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1421))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1422))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1423, const char *__anonymous_object1424, unsigned long int __anonymous_object1425))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1426, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char "))) , _tmp_cp_ret2)), __v__c_1))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1453))(&_thunk0))))) , _tmp_cp_ret4));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1349))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1350))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1351, _Bool __anonymous_object1352))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1353))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1354, const char *__anonymous_object1355))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1356))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1357, _Bool __anonymous_object1358))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1359))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1360))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1363))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1364, const char *__anonymous_object1365))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1366))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1367, const char *__anonymous_object1368))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1369))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1370))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1371, const char *__anonymous_object1372, unsigned long int __anonymous_object1373))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1374, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1375))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1376))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1377, _Bool __anonymous_object1378))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1379))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1380, const char *__anonymous_object1381))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1382))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1383, _Bool __anonymous_object1384))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1385))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1386))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1389))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1390, const char *__anonymous_object1391))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1392))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1393, const char *__anonymous_object1394))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1395))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1396))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1397, const char *__anonymous_object1398, unsigned long int __anonymous_object1399))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1400, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0c__1(((_Bool (*)(void *__anonymous_object1401))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1402))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1403, _Bool __anonymous_object1404))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1405))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1406, const char *__anonymous_object1407))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1408))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1409, _Bool __anonymous_object1410))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1411))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1412))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1415))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1416, const char *__anonymous_object1417))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1418))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1419, const char *__anonymous_object1420))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1421))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1422))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1423, const char *__anonymous_object1424, unsigned long int __anonymous_object1425))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1426, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "char "))) , _tmp_cp_ret2)), __v__c_1))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1453))(&_thunk0))))) , _tmp_cp_ret4));
+}
 void __f__F_Sc__1(signed char __v__Sc_1){
 …
     struct ofstream *_tmp_cp_ret7;
     __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1454))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1455))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1456, _Bool __anonymous_object1457))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1458))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1459, const char *__anonymous_object1460))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1461))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1462, _Bool __anonymous_object1463))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1464))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1465))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1468))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1469, const char *__anonymous_object1470))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1471))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1474))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1475))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1476, const char *__anonymous_object1477, unsigned long int __anonymous_object1478))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1479, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1480))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1481))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1482, _Bool __anonymous_object1483))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1484))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1485, const char *__anonymous_object1486))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1487))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1488, _Bool __anonymous_object1489))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1490))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1491))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1494))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1495, const char *__anonymous_object1496))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1497))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1498, const char *__anonymous_object1499))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1500))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1501))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1502, const char *__anonymous_object1503, unsigned long int __anonymous_object1504))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1505, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1506))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1507))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1508, _Bool __anonymous_object1509))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1510))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1511, const char *__anonymous_object1512))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1513))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1514, _Bool __anonymous_object1515))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1516))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1517))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1520))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1521, const char *__anonymous_object1522))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1523))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1524, const char *__anonymous_object1525))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1526))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1527))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1528, const char *__anonymous_object1529, unsigned long int __anonymous_object1530))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1531, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char "))) , _tmp_cp_ret5)), __v__Sc_1))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1558))(&_thunk1))))) , _tmp_cp_ret7));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1454))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1455))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1456, _Bool __anonymous_object1457))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1458))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1459, const char *__anonymous_object1460))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1461))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1462, _Bool __anonymous_object1463))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1464))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1465))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1468))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1469, const char *__anonymous_object1470))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1471))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1474))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1475))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1476, const char *__anonymous_object1477, unsigned long int __anonymous_object1478))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1479, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1480))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1481))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1482, _Bool __anonymous_object1483))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1484))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1485, const char *__anonymous_object1486))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1487))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1488, _Bool __anonymous_object1489))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1490))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1491))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1494))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1495, const char *__anonymous_object1496))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1497))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1498, const char *__anonymous_object1499))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1500))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1501))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1502, const char *__anonymous_object1503, unsigned long int __anonymous_object1504))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1505, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Sc__1(((_Bool (*)(void *__anonymous_object1506))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1507))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1508, _Bool __anonymous_object1509))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1510))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1511, const char *__anonymous_object1512))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1513))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1514, _Bool __anonymous_object1515))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1516))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1517))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1520))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1521, const char *__anonymous_object1522))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1523))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1524, const char *__anonymous_object1525))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1526))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1527))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1528, const char *__anonymous_object1529, unsigned long int __anonymous_object1530))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1531, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "signed char "))) , _tmp_cp_ret5)), __v__Sc_1))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1558))(&_thunk1))))) , _tmp_cp_ret7));
+}
 void __f__F_Uc__1(unsigned char __v__Uc_1){
 …
     struct ofstream *_tmp_cp_ret10;
     __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1559))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1560))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1561, _Bool __anonymous_object1562))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1563))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1564, const char *__anonymous_object1565))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1566))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1567, _Bool __anonymous_object1568))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1569))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1570))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1573))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1574, const char *__anonymous_object1575))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1576))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1579))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1580))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1581, const char *__anonymous_object1582, unsigned long int __anonymous_object1583))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1584, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1585))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1586))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1587, _Bool __anonymous_object1588))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1589))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1590, const char *__anonymous_object1591))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1592))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1593, _Bool __anonymous_object1594))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1595))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1596))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1599))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1600, const char *__anonymous_object1601))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1602))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1603, const char *__anonymous_object1604))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1605))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1606))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1607, const char *__anonymous_object1608, unsigned long int __anonymous_object1609))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1610, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1611))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1612))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1613, _Bool __anonymous_object1614))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1615))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1616, const char *__anonymous_object1617))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1618))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1619, _Bool __anonymous_object1620))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1621))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1622))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1625))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1626, const char *__anonymous_object1627))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1628))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1629, const char *__anonymous_object1630))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1631))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1632))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1633, const char *__anonymous_object1634, unsigned long int __anonymous_object1635))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1636, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char "))) , _tmp_cp_ret8)), __v__Uc_1))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1663))(&_thunk2))))) , _tmp_cp_ret10));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1559))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1560))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1561, _Bool __anonymous_object1562))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1563))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1564, const char *__anonymous_object1565))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1566))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1567, _Bool __anonymous_object1568))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1569))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1570))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1573))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1574, const char *__anonymous_object1575))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1576))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1579))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1580))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1581, const char *__anonymous_object1582, unsigned long int __anonymous_object1583))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1584, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1585))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1586))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1587, _Bool __anonymous_object1588))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1589))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1590, const char *__anonymous_object1591))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1592))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1593, _Bool __anonymous_object1594))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1595))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1596))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1599))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1600, const char *__anonymous_object1601))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1602))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1603, const char *__anonymous_object1604))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1605))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1606))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1607, const char *__anonymous_object1608, unsigned long int __anonymous_object1609))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1610, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Uc__1(((_Bool (*)(void *__anonymous_object1611))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1612))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1613, _Bool __anonymous_object1614))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1615))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1616, const char *__anonymous_object1617))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1618))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1619, _Bool __anonymous_object1620))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1621))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1622))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1625))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1626, const char *__anonymous_object1627))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1628))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1629, const char *__anonymous_object1630))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1631))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1632))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1633, const char *__anonymous_object1634, unsigned long int __anonymous_object1635))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1636, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "unsigned char "))) , _tmp_cp_ret8)), __v__Uc_1))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1663))(&_thunk2))))) , _tmp_cp_ret10));
+}
 void __f__F_s__1(signed short int __v__s_1){
 …
     struct ofstream *_tmp_cp_ret13;
     __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1664))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1665))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1666, _Bool __anonymous_object1667))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1668))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1669, const char *__anonymous_object1670))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1671))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1672, _Bool __anonymous_object1673))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1674))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1675))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1678))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1679, const char *__anonymous_object1680))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1681))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1684))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1685))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1686, const char *__anonymous_object1687, unsigned long int __anonymous_object1688))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1689, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1690))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1691))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1692, _Bool __anonymous_object1693))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1694))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1695, const char *__anonymous_object1696))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1697))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1698, _Bool __anonymous_object1699))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1700))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1701))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1704))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1705, const char *__anonymous_object1706))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1707))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1708, const char *__anonymous_object1709))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1710))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1711))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1712, const char *__anonymous_object1713, unsigned long int __anonymous_object1714))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1715, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1716))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1717))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1718, _Bool __anonymous_object1719))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1720))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1721, const char *__anonymous_object1722))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1723))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1724, _Bool __anonymous_object1725))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1726))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1727))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1730))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1731, const char *__anonymous_object1732))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1733))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1734, const char *__anonymous_object1735))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1736))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1737))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1738, const char *__anonymous_object1739, unsigned long int __anonymous_object1740))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1741, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int"))) , _tmp_cp_ret11)), __v__s_1))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1768))(&_thunk3))))) , _tmp_cp_ret13));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1664))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1665))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1666, _Bool __anonymous_object1667))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1668))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1669, const char *__anonymous_object1670))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1671))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1672, _Bool __anonymous_object1673))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1674))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1675))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1678))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1679, const char *__anonymous_object1680))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1681))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1684))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1685))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1686, const char *__anonymous_object1687, unsigned long int __anonymous_object1688))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1689, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1690))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1691))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1692, _Bool __anonymous_object1693))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1694))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1695, const char *__anonymous_object1696))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1697))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1698, _Bool __anonymous_object1699))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1700))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1701))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1704))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1705, const char *__anonymous_object1706))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1707))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1708, const char *__anonymous_object1709))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1710))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1711))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1712, const char *__anonymous_object1713, unsigned long int __anonymous_object1714))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1715, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0s__1(((_Bool (*)(void *__anonymous_object1716))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1717))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1718, _Bool __anonymous_object1719))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1720))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1721, const char *__anonymous_object1722))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1723))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1724, _Bool __anonymous_object1725))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1726))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1727))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1730))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1731, const char *__anonymous_object1732))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1733))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1734, const char *__anonymous_object1735))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1736))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1737))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1738, const char *__anonymous_object1739, unsigned long int __anonymous_object1740))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1741, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "signed short int"))) , _tmp_cp_ret11)), __v__s_1))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1768))(&_thunk3))))) , _tmp_cp_ret13));
+}
 void __f__F_Us__1(unsigned short int __v__Us_1){
 …
     struct ofstream *_tmp_cp_ret16;
     __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1769))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1770))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1771, _Bool __anonymous_object1772))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1773))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1774, const char *__anonymous_object1775))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1776))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1777, _Bool __anonymous_object1778))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1779))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1780))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1783))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1784, const char *__anonymous_object1785))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1786))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1789))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1790))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1791, const char *__anonymous_object1792, unsigned long int __anonymous_object1793))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1794, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1795))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1796))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1797, _Bool __anonymous_object1798))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1799))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1800, const char *__anonymous_object1801))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1802))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1803, _Bool __anonymous_object1804))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1805))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1806))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1809))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1810, const char *__anonymous_object1811))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1812))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1813, const char *__anonymous_object1814))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1815))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1816))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1817, const char *__anonymous_object1818, unsigned long int __anonymous_object1819))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1820, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1821))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1822))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1823, _Bool __anonymous_object1824))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1825))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1826, const char *__anonymous_object1827))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1828))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1829, _Bool __anonymous_object1830))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1831))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1832))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1835))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1836, const char *__anonymous_object1837))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1838))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1839, const char *__anonymous_object1840))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1841))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1842))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1843, const char *__anonymous_object1844, unsigned long int __anonymous_object1845))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1846, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int"))) , _tmp_cp_ret14)), __v__Us_1))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1873))(&_thunk4))))) , _tmp_cp_ret16));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1769))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1770))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1771, _Bool __anonymous_object1772))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1773))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1774, const char *__anonymous_object1775))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1776))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1777, _Bool __anonymous_object1778))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1779))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1780))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1783))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1784, const char *__anonymous_object1785))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1786))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1789))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1790))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1791, const char *__anonymous_object1792, unsigned long int __anonymous_object1793))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1794, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1795))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1796))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1797, _Bool __anonymous_object1798))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1799))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1800, const char *__anonymous_object1801))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1802))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1803, _Bool __anonymous_object1804))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1805))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1806))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1809))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1810, const char *__anonymous_object1811))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1812))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1813, const char *__anonymous_object1814))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1815))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1816))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1817, const char *__anonymous_object1818, unsigned long int __anonymous_object1819))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1820, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Us__1(((_Bool (*)(void *__anonymous_object1821))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1822))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1823, _Bool __anonymous_object1824))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1825))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1826, const char *__anonymous_object1827))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1828))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1829, _Bool __anonymous_object1830))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1831))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1832))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1835))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1836, const char *__anonymous_object1837))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1838))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1839, const char *__anonymous_object1840))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1841))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1842))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1843, const char *__anonymous_object1844, unsigned long int __anonymous_object1845))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1846, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "unsigned short int"))) , _tmp_cp_ret14)), __v__Us_1))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1873))(&_thunk4))))) , _tmp_cp_ret16));
+}
 void __f__F_Ul__1(unsigned long int __v__Ul_1){
 …
     struct ofstream *_tmp_cp_ret19;
     __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1874))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1875))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1876, _Bool __anonymous_object1877))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1878))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1879, const char *__anonymous_object1880))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1881))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1882, _Bool __anonymous_object1883))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1884))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1885))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1888))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1889, const char *__anonymous_object1890))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1891))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1894))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1895))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1896, const char *__anonymous_object1897, unsigned long int __anonymous_object1898))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1899, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret19=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1900))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1901))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1902, _Bool __anonymous_object1903))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1904))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1905, const char *__anonymous_object1906))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1907))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1908, _Bool __anonymous_object1909))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1910))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1911))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1914))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1915, const char *__anonymous_object1916))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1917))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1918, const char *__anonymous_object1919))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1920))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1921))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1922, const char *__anonymous_object1923, unsigned long int __anonymous_object1924))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1925, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(((_Bool (*)(void *__anonymous_object1926))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1927))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1928, _Bool __anonymous_object1929))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1930))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1931, const char *__anonymous_object1932))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1933))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1934, _Bool __anonymous_object1935))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1936))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1937))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1940))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1941, const char *__anonymous_object1942))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1943))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1944, const char *__anonymous_object1945))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1946))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1947))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1948, const char *__anonymous_object1949, unsigned long int __anonymous_object1950))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1951, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1952))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1953))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1954, _Bool __anonymous_object1955))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1956))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1957, const char *__anonymous_object1958))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1959))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1960, _Bool __anonymous_object1961))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1962))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1963))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1964))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1966))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1967, const char *__anonymous_object1968))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1969))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1970, const char *__anonymous_object1971))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1972))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1973))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1974, const char *__anonymous_object1975, unsigned long int __anonymous_object1976))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1977, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t"))) , _tmp_cp_ret17)), __v__Ul_1))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object1978))(&_thunk5))))) , _tmp_cp_ret19));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1874))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1875))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1876, _Bool __anonymous_object1877))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1878))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1879, const char *__anonymous_object1880))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1881))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1882, _Bool __anonymous_object1883))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1884))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1885))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1888))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1889, const char *__anonymous_object1890))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1891))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1894))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1895))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1896, const char *__anonymous_object1897, unsigned long int __anonymous_object1898))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1899, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret19=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1900))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1901))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1902, _Bool __anonymous_object1903))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1904))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1905, const char *__anonymous_object1906))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1907))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1908, _Bool __anonymous_object1909))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1910))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1911))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1914))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1915, const char *__anonymous_object1916))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1917))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1918, const char *__anonymous_object1919))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1920))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1921))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1922, const char *__anonymous_object1923, unsigned long int __anonymous_object1924))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1925, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Ul__1(((_Bool (*)(void *__anonymous_object1926))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1927))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1928, _Bool __anonymous_object1929))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1930))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1931, const char *__anonymous_object1932))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1933))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1934, _Bool __anonymous_object1935))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1936))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1937))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1940))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1941, const char *__anonymous_object1942))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1943))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1944, const char *__anonymous_object1945))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1946))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1947))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1948, const char *__anonymous_object1949, unsigned long int __anonymous_object1950))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1951, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1952))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1953))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1954, _Bool __anonymous_object1955))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1956))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1957, const char *__anonymous_object1958))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1959))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1960, _Bool __anonymous_object1961))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1962))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1963))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1964))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1966))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1967, const char *__anonymous_object1968))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1969))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1970, const char *__anonymous_object1971))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1972))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1973))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1974, const char *__anonymous_object1975, unsigned long int __anonymous_object1976))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1977, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "size_t"))) , _tmp_cp_ret17)), __v__Ul_1))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object1978))(&_thunk5))))) , _tmp_cp_ret19));
+}
 signed int __main__Fi___1(){

src/tests/.expect/literals.x86.txt

-              r3ef35bd
+              reba74ba
 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_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0b__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object103), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, _Bool __anonymous_object109);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object131), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, char __anonymous_object137);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object159), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, signed char __anonymous_object165);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object187), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, unsigned char __anonymous_object193);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object215), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, signed short int __anonymous_object221);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object243), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, unsigned short int __anonymous_object249);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object271), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, signed int __anonymous_object277);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object299), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, unsigned int __anonymous_object305);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object327), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long int __anonymous_object333);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object355), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, signed long long int __anonymous_object361);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ul__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object383), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long int __anonymous_object389);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object411), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, unsigned long long int __anonymous_object417);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object439), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, float __anonymous_object445);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object467), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, double __anonymous_object473);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object495), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, long double __anonymous_object501);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object523), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, float _Complex __anonymous_object529);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object551), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, double _Complex __anonymous_object557);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object579), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, long double _Complex __anonymous_object585);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object607), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object635), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const void *__anonymous_object641);
 void *___operator_bitor__A0_2_0_1____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____operator_bitor__PFRd0_Rd0tVARGS2__FRd0_Rd0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object642)(), void *__anonymous_object643, void *__anonymous_object644), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object645)(), void *__anonymous_object646, void *__anonymous_object647), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object648)(), void *__anonymous_object649, void *__anonymous_object650), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object651)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object652, void *__anonymous_object653), __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_object654, void *__anonymous_object655), __attribute__ ((unused)) void (*___constructor__PF_R2tT__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*___constructor__PF_R2tT2tT__1)(void *__anonymous_object657, void *__anonymous_object658), __attribute__ ((unused)) void (*___destructor__PF_R2tT__1)(void *__anonymous_object659), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype2tT__1)(void *__anonymous_object660, void *__anonymous_object661), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object664, _Bool __anonymous_object665), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object666), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object667, const char *__anonymous_object668), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object669), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object670, _Bool __anonymous_object671), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object673), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object676), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object677, const char *__anonymous_object678), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object679), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object680, const char *__anonymous_object681), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object684, const char *__anonymous_object685, unsigned long int __anonymous_object686), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object687, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype7tParams__1)(void *__anonymous_object688, void *__anonymous_object689), void *__os__R7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object692, _Bool __anonymous_object693), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object694), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object695, const char *__anonymous_object696), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object697), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object698, _Bool __anonymous_object699), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object700), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object701), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object703), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object704), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object705, const char *__anonymous_object706), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object707), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object708, const char *__anonymous_object709), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object712, const char *__anonymous_object713, unsigned long int __anonymous_object714), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object715, const char *__fmt__PCc_1, ...), void *__anonymous_object716, void *(*__anonymous_object717)(void *__anonymous_object718));
 void *__endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object720), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object721, _Bool __anonymous_object722), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object723), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object724, const char *__anonymous_object725), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object733), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object734, const char *__anonymous_object735), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object737, const char *__anonymous_object738), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object741, const char *__anonymous_object742, unsigned long int __anonymous_object743), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object744, const char *__fmt__PCc_1, ...), void *__anonymous_object745);
 void *__sep__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772);
 void *__sepTuple__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object775, _Bool __anonymous_object776), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object777), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object778, const char *__anonymous_object779), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object788, const char *__anonymous_object789), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object791, const char *__anonymous_object792), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object795, const char *__anonymous_object796, unsigned long int __anonymous_object797), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object798, const char *__fmt__PCc_1, ...), void *__anonymous_object799);
 void *__sepOn__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object801), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object802, _Bool __anonymous_object803), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object805, const char *__anonymous_object806), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object811), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object815, const char *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object821), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object822, const char *__anonymous_object823, unsigned long int __anonymous_object824), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object825, const char *__fmt__PCc_1, ...), void *__anonymous_object826);
 void *__sepOff__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object828), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object829, _Bool __anonymous_object830), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object832, const char *__anonymous_object833), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object838), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object842, const char *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object848), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object849, const char *__anonymous_object850, unsigned long int __anonymous_object851), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object852, const char *__fmt__PCc_1, ...), void *__anonymous_object853);
 void *__sepDisable__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object855), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object856, _Bool __anonymous_object857), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object859, const char *__anonymous_object860), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object862, _Bool __anonymous_object863), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object865), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object869, const char *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object875), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object876, const char *__anonymous_object877, unsigned long int __anonymous_object878), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object879, const char *__fmt__PCc_1, ...), void *__anonymous_object880);
 void *__sepEnable__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object882), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object883, _Bool __anonymous_object884), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object886, const char *__anonymous_object887), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object889, _Bool __anonymous_object890), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object896, const char *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object902), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object903, const char *__anonymous_object904, unsigned long int __anonymous_object905), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object906, const char *__fmt__PCc_1, ...), void *__anonymous_object907);
 void __write__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____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_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object908)(), void *__anonymous_object909), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object910)(), void *__anonymous_object911, void *__anonymous_object912), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object913)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object914), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object915)(), void *__anonymous_object916, void *__anonymous_object917), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object918)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object919, void *__anonymous_object920), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object921)(), void *__anonymous_object922, void *__anonymous_object923), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object924)(), void *__anonymous_object925, void *__anonymous_object926), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object927)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object928, void *__anonymous_object929), __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_object930, void *__anonymous_object931), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object932), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object933, void *__anonymous_object934), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object935), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object936, void *__anonymous_object937), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object959), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object964, void *__anonymous_object965), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object969), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object970), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object971), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object974, void *__anonymous_object975), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object976), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
 void __write_reverse__A0_3_0_0____operator_assign__PFd1_Rd1d1____constructor__PF_Rd1____constructor__PF_Rd1d1____destructor__PF_Rd1____operator_bitor__PFRd0_Rd0d1___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc____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_d2d2Rd0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object977)(), void *__anonymous_object978), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object979)(), void *__anonymous_object980, void *__anonymous_object981), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object982)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object983), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object984)(), void *__anonymous_object985, void *__anonymous_object986), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object987)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object988, void *__anonymous_object989), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object990)(), void *__anonymous_object991, void *__anonymous_object992), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object993)(), void *__anonymous_object994, void *__anonymous_object995), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object996)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object997, void *__anonymous_object998), __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_object999, void *__anonymous_object1000), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*___constructor__PF_R9telt_type9telt_type__1)(void *__anonymous_object1002, void *__anonymous_object1003), __attribute__ ((unused)) void (*___destructor__PF_R9telt_type__1)(void *__anonymous_object1004), __attribute__ ((unused)) void *(*___operator_bitor__PFR7tostype_R7tostype9telt_type__1)(void *__anonymous_object1005, void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1009, _Bool __anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1015, _Bool __anonymous_object1016), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1017), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1018), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1019), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1020), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1021), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1022, const char *__anonymous_object1023), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1024), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1025, const char *__anonymous_object1026), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1028), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1029, const char *__anonymous_object1030, unsigned long int __anonymous_object1031), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1032, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__PF14titerator_type_R14titerator_type14titerator_type__1)(void *__anonymous_object1033, void *__anonymous_object1034), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type__1)(void *__anonymous_object1035), __attribute__ ((unused)) void (*___constructor__PF_R14titerator_type14titerator_type__1)(void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*___destructor__PF_R14titerator_type__1)(void *__anonymous_object1038), __attribute__ ((unused)) void *(*___operator_preincr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1039), __attribute__ ((unused)) void *(*___operator_predecr__PF14titerator_type_R14titerator_type__1)(void *__anonymous_object1040), __attribute__ ((unused)) signed int (*___operator_equal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) signed int (*___operator_notequal__PFi_14titerator_type14titerator_type__1)(void *__anonymous_object1043, void *__anonymous_object1044), __attribute__ ((unused)) void *(*___operator_deref__PFR9telt_type_14titerator_type__1)(void *__anonymous_object1045), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__R7tostype_1);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rb__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1046), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1047), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1048, char *__anonymous_object1049, unsigned long int __anonymous_object1050), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1051, char __anonymous_object1052), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1053, const char *__fmt__PCc_1, ...), void *__anonymous_object1054, _Bool *__anonymous_object1055);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1056), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1058, char *__anonymous_object1059, unsigned long int __anonymous_object1060), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1061, char __anonymous_object1062), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1063, const char *__fmt__PCc_1, ...), void *__anonymous_object1064, char *__anonymous_object1065);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RSc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1066), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1068, char *__anonymous_object1069, unsigned long int __anonymous_object1070), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1071, char __anonymous_object1072), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1073, const char *__fmt__PCc_1, ...), void *__anonymous_object1074, signed char *__anonymous_object1075);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUc__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1076), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1078, char *__anonymous_object1079, unsigned long int __anonymous_object1080), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1081, char __anonymous_object1082), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1083, const char *__fmt__PCc_1, ...), void *__anonymous_object1084, unsigned char *__anonymous_object1085);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1086), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1087), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1088, char *__anonymous_object1089, unsigned long int __anonymous_object1090), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1091, char __anonymous_object1092), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1093, const char *__fmt__PCc_1, ...), void *__anonymous_object1094, signed short int *__anonymous_object1095);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUs__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1097), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1098, char *__anonymous_object1099, unsigned long int __anonymous_object1100), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1101, char __anonymous_object1102), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1103, const char *__fmt__PCc_1, ...), void *__anonymous_object1104, unsigned short int *__anonymous_object1105);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Ri__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1106), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1107), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1108, char *__anonymous_object1109, unsigned long int __anonymous_object1110), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1111, char __anonymous_object1112), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1113, const char *__fmt__PCc_1, ...), void *__anonymous_object1114, signed int *__anonymous_object1115);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUi__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1116), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1117), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1118, char *__anonymous_object1119, unsigned long int __anonymous_object1120), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1121, char __anonymous_object1122), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1123, const char *__fmt__PCc_1, ...), void *__anonymous_object1124, unsigned int *__anonymous_object1125);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1126), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1127), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1128, char *__anonymous_object1129, unsigned long int __anonymous_object1130), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1131, char __anonymous_object1132), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1133, const char *__fmt__PCc_1, ...), void *__anonymous_object1134, signed long int *__anonymous_object1135);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1136), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1137), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1138, char *__anonymous_object1139, unsigned long int __anonymous_object1140), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1141, char __anonymous_object1142), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1143, const char *__fmt__PCc_1, ...), void *__anonymous_object1144, signed long long int *__anonymous_object1145);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUl__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1146), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1147), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1148, char *__anonymous_object1149, unsigned long int __anonymous_object1150), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1151, char __anonymous_object1152), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1153, const char *__fmt__PCc_1, ...), void *__anonymous_object1154, unsigned long int *__anonymous_object1155);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RUq__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1156), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1157), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1158, char *__anonymous_object1159, unsigned long int __anonymous_object1160), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1161, char __anonymous_object1162), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1163, const char *__fmt__PCc_1, ...), void *__anonymous_object1164, unsigned long long int *__anonymous_object1165);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1166), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1167), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1168, char *__anonymous_object1169, unsigned long int __anonymous_object1170), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1171, char __anonymous_object1172), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1173, const char *__fmt__PCc_1, ...), void *__anonymous_object1174, float *__anonymous_object1175);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1176), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1177), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1178, char *__anonymous_object1179, unsigned long int __anonymous_object1180), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1181, char __anonymous_object1182), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1183, const char *__fmt__PCc_1, ...), void *__anonymous_object1184, double *__anonymous_object1185);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0Rr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1186), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1187), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1188, char *__anonymous_object1189, unsigned long int __anonymous_object1190), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1191, char __anonymous_object1192), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1193, const char *__fmt__PCc_1, ...), void *__anonymous_object1194, long double *__anonymous_object1195);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXf__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1196), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1197), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1198, char *__anonymous_object1199, unsigned long int __anonymous_object1200), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1201, char __anonymous_object1202), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1203, const char *__fmt__PCc_1, ...), void *__anonymous_object1204, float _Complex *__anonymous_object1205);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXd__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1206), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1207), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1208, char *__anonymous_object1209, unsigned long int __anonymous_object1210), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1211, char __anonymous_object1212), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1213, const char *__fmt__PCc_1, ...), void *__anonymous_object1214, double _Complex *__anonymous_object1215);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0RXr__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1216), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1217), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1218, char *__anonymous_object1219, unsigned long int __anonymous_object1220), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1221, char __anonymous_object1222), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1223, const char *__fmt__PCc_1, ...), void *__anonymous_object1224, long double _Complex *__anonymous_object1225);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1226), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1227), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1228, char *__anonymous_object1229, unsigned long int __anonymous_object1230), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1231, char __anonymous_object1232), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1233, const char *__fmt__PCc_1, ...), void *__anonymous_object1234, void *(*__anonymous_object1235)(void *__anonymous_object1236));
 void *__endl__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd0__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1237), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1238), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1239, char *__anonymous_object1240, unsigned long int __anonymous_object1241), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1242, char __anonymous_object1243), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1244, const char *__fmt__PCc_1, ...), void *__is__R7tistype_1);
+void __for_each__A0_2_0_0____operator_assign__Fd0_d0d0____constructor__F_d0____constructor__F_d0d0____destructor__F_d0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_preincr__Fd0_d0____operator_predecr__Fd0_d0____operator_equal__Fi_d0d0____operator_notequal__Fi_d0d0____operator_deref__Fd1_d0__F_d0d0F_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__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object21, void *__anonymous_object22), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object23), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object24, void *__anonymous_object25), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object26), __attribute__ ((unused)) void *(*___operator_assign__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object27, void *__anonymous_object28), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object29), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object30, void *__anonymous_object31), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object32), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object33), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object34), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object35, void *__anonymous_object36), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object37, void *__anonymous_object38), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object39), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__F_9telt_type__1)(void *__anonymous_object40));
+void __for_each_reverse__A0_2_0_0____operator_assign__Fd0_d0d0____constructor__F_d0____constructor__F_d0d0____destructor__F_d0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_preincr__Fd0_d0____operator_predecr__Fd0_d0____operator_equal__Fi_d0d0____operator_notequal__Fi_d0d0____operator_deref__Fd1_d0__F_d0d0F_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__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object62, void *__anonymous_object63), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object64), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object65, void *__anonymous_object66), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object67), __attribute__ ((unused)) void *(*___operator_assign__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object68, void *__anonymous_object69), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object70), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object71, void *__anonymous_object72), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object73), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object74), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object75), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object76, void *__anonymous_object77), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object78, void *__anonymous_object79), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object80), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void (*__func__F_9telt_type__1)(void *__anonymous_object81));
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0b__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object82), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object83), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object84, _Bool __anonymous_object85), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object86), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object87, const char *__anonymous_object88), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object89), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object90, _Bool __anonymous_object91), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object92), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object93), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object94), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object95), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object96), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object97, const char *__anonymous_object98), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object99), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object100, const char *__anonymous_object101), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object102), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object103), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object104, const char *__anonymous_object105, unsigned long int __anonymous_object106), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object107, const char *__fmt__PCc_1, ...), void *__anonymous_object108, _Bool __anonymous_object109);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0c__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object110), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object111), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object112, _Bool __anonymous_object113), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object114), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object115, const char *__anonymous_object116), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object117), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object118, _Bool __anonymous_object119), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object120), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object121), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object122), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object123), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object124), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object125, const char *__anonymous_object126), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object127), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object128, const char *__anonymous_object129), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object130), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object131), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object132, const char *__anonymous_object133, unsigned long int __anonymous_object134), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object135, const char *__fmt__PCc_1, ...), void *__anonymous_object136, char __anonymous_object137);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Sc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object138), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object139), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object140, _Bool __anonymous_object141), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object142), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object143, const char *__anonymous_object144), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object145), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object146, _Bool __anonymous_object147), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object148), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object149), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object150), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object151), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object152), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object153, const char *__anonymous_object154), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object155), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object156, const char *__anonymous_object157), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object158), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object159), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object160, const char *__anonymous_object161, unsigned long int __anonymous_object162), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object163, const char *__fmt__PCc_1, ...), void *__anonymous_object164, signed char __anonymous_object165);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Uc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object166), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object167), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object168, _Bool __anonymous_object169), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object170), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object171, const char *__anonymous_object172), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object173), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object174, _Bool __anonymous_object175), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object176), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object177), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object178), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object179), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object180), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object181, const char *__anonymous_object182), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object183), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object184, const char *__anonymous_object185), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object186), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object187), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object188, const char *__anonymous_object189, unsigned long int __anonymous_object190), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object191, const char *__fmt__PCc_1, ...), void *__anonymous_object192, unsigned char __anonymous_object193);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0s__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object194), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object195), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object196, _Bool __anonymous_object197), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object198), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object199, const char *__anonymous_object200), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object201), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object202, _Bool __anonymous_object203), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object204), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object205), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object206), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object207), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object208), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object209, const char *__anonymous_object210), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object211), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object212, const char *__anonymous_object213), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object214), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object215), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object216, const char *__anonymous_object217, unsigned long int __anonymous_object218), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object219, const char *__fmt__PCc_1, ...), void *__anonymous_object220, signed short int __anonymous_object221);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Us__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object222), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object223), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object224, _Bool __anonymous_object225), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object226), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object227, const char *__anonymous_object228), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object229), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object230, _Bool __anonymous_object231), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object232), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object233), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object234), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object235), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object236), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object237, const char *__anonymous_object238), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object239), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object240, const char *__anonymous_object241), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object242), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object243), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object244, const char *__anonymous_object245, unsigned long int __anonymous_object246), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object247, const char *__fmt__PCc_1, ...), void *__anonymous_object248, unsigned short int __anonymous_object249);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0i__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object250), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object251), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object252, _Bool __anonymous_object253), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object254), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object255, const char *__anonymous_object256), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object257), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object258, _Bool __anonymous_object259), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object260), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object261), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object262), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object263), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object264), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object265, const char *__anonymous_object266), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object267), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object268, const char *__anonymous_object269), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object270), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object271), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object272, const char *__anonymous_object273, unsigned long int __anonymous_object274), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object275, const char *__fmt__PCc_1, ...), void *__anonymous_object276, signed int __anonymous_object277);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Ui__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object278), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object279), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object280, _Bool __anonymous_object281), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object282), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object283, const char *__anonymous_object284), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object285), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object286, _Bool __anonymous_object287), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object288), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object289), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object290), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object291), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object292), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object293, const char *__anonymous_object294), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object295), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object296, const char *__anonymous_object297), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object298), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object299), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object300, const char *__anonymous_object301, unsigned long int __anonymous_object302), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object303, const char *__fmt__PCc_1, ...), void *__anonymous_object304, unsigned int __anonymous_object305);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0l__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object306), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object307), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object308, _Bool __anonymous_object309), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object310), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object311, const char *__anonymous_object312), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object313), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object314, _Bool __anonymous_object315), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object316), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object317), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object318), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object319), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object320), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object321, const char *__anonymous_object322), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object323), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object324, const char *__anonymous_object325), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object326), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object327), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object328, const char *__anonymous_object329, unsigned long int __anonymous_object330), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object331, const char *__fmt__PCc_1, ...), void *__anonymous_object332, signed long int __anonymous_object333);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0q__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object334), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object335), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object336, _Bool __anonymous_object337), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object338), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object339, const char *__anonymous_object340), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object341), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object342, _Bool __anonymous_object343), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object344), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object345), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object346), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object347), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object348), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object349, const char *__anonymous_object350), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object351), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object352, const char *__anonymous_object353), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object354), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object355), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object356, const char *__anonymous_object357, unsigned long int __anonymous_object358), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object359, const char *__fmt__PCc_1, ...), void *__anonymous_object360, signed long long int __anonymous_object361);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Ul__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object362), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object363), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object364, _Bool __anonymous_object365), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object366), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object367, const char *__anonymous_object368), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object369), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object370, _Bool __anonymous_object371), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object372), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object373), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object374), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object375), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object376), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object377, const char *__anonymous_object378), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object379), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object380, const char *__anonymous_object381), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object382), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object383), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object384, const char *__anonymous_object385, unsigned long int __anonymous_object386), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object387, const char *__fmt__PCc_1, ...), void *__anonymous_object388, unsigned long int __anonymous_object389);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Uq__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object390), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object391), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object392, _Bool __anonymous_object393), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object394), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object395, const char *__anonymous_object396), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object397), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object398, _Bool __anonymous_object399), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object400), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object401), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object402), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object403), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object404), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object405, const char *__anonymous_object406), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object407), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object408, const char *__anonymous_object409), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object410), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object411), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object412, const char *__anonymous_object413, unsigned long int __anonymous_object414), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object415, const char *__fmt__PCc_1, ...), void *__anonymous_object416, unsigned long long int __anonymous_object417);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0f__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object418), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object419), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object420, _Bool __anonymous_object421), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object422), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object423, const char *__anonymous_object424), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object425), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object426, _Bool __anonymous_object427), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object428), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object429), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object430), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object431), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object432), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object433, const char *__anonymous_object434), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object435), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object436, const char *__anonymous_object437), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object438), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object439), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object440, const char *__anonymous_object441, unsigned long int __anonymous_object442), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object443, const char *__fmt__PCc_1, ...), void *__anonymous_object444, float __anonymous_object445);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0d__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object446), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object447), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object448, _Bool __anonymous_object449), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object450), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object451, const char *__anonymous_object452), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object453), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object454, _Bool __anonymous_object455), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object456), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object457), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object458), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object459), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object460), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object461, const char *__anonymous_object462), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object463), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object464, const char *__anonymous_object465), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object466), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object467), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object468, const char *__anonymous_object469, unsigned long int __anonymous_object470), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object471, const char *__fmt__PCc_1, ...), void *__anonymous_object472, double __anonymous_object473);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0r__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object474), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object475), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object476, _Bool __anonymous_object477), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object478), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object479, const char *__anonymous_object480), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object481), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object482, _Bool __anonymous_object483), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object484), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object485), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object486), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object487), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object488), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object489, const char *__anonymous_object490), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object491), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object492, const char *__anonymous_object493), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object494), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object495), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object496, const char *__anonymous_object497, unsigned long int __anonymous_object498), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object499, const char *__fmt__PCc_1, ...), void *__anonymous_object500, long double __anonymous_object501);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Xf__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object502), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object503), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object504, _Bool __anonymous_object505), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object506), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object507, const char *__anonymous_object508), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object509), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object510, _Bool __anonymous_object511), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object512), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object513), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object514), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object515), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object516), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object517, const char *__anonymous_object518), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object519), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object520, const char *__anonymous_object521), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object522), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object523), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object524, const char *__anonymous_object525, unsigned long int __anonymous_object526), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object527, const char *__fmt__PCc_1, ...), void *__anonymous_object528, float _Complex __anonymous_object529);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Xd__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object530), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object531), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object532, _Bool __anonymous_object533), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object534), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object535, const char *__anonymous_object536), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object537), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object538, _Bool __anonymous_object539), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object540), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object541), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object542), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object543), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object544), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object545, const char *__anonymous_object546), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object547), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object548, const char *__anonymous_object549), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object550), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object551), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object552, const char *__anonymous_object553, unsigned long int __anonymous_object554), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object555, const char *__fmt__PCc_1, ...), void *__anonymous_object556, double _Complex __anonymous_object557);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Xr__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object558), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object559), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object560, _Bool __anonymous_object561), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object562), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object563, const char *__anonymous_object564), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object565), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object566, _Bool __anonymous_object567), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object568), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object569), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object570), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object571), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object572), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object573, const char *__anonymous_object574), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object575), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object576, const char *__anonymous_object577), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object578), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object579), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object580, const char *__anonymous_object581, unsigned long int __anonymous_object582), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object583, const char *__fmt__PCc_1, ...), void *__anonymous_object584, long double _Complex __anonymous_object585);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object586), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object587), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object588, _Bool __anonymous_object589), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object590), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object591, const char *__anonymous_object592), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object593), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object594, _Bool __anonymous_object595), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object596), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object597), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object598), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object599), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object600), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object601, const char *__anonymous_object602), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object603), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object604, const char *__anonymous_object605), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object606), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object607), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object608, const char *__anonymous_object609, unsigned long int __anonymous_object610), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object611, const char *__fmt__PCc_1, ...), void *__anonymous_object612, const char *__anonymous_object613);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCv__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object614), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object615), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object616, _Bool __anonymous_object617), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object618), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object619, const char *__anonymous_object620), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object621), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object622, _Bool __anonymous_object623), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object624), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object625), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object626), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object627), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object628), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object629, const char *__anonymous_object630), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object631), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object632, const char *__anonymous_object633), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object634), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object635), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object636, const char *__anonymous_object637, unsigned long int __anonymous_object638), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object639, const char *__fmt__PCc_1, ...), void *__anonymous_object640, const void *__anonymous_object641);
+void *___operator_bitor__A0_2_0_1____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_bitor__Fd0_d0tVARGS2__Fd0_d0d1tVARGS2__1(__attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype7tParams_M_MP)(void (*__anonymous_object642)(), void *__anonymous_object643, void *__anonymous_object644), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype2tT_M_MP)(void (*__anonymous_object645)(), void *__anonymous_object646, void *__anonymous_object647), __attribute__ ((unused)) void (*_adapterF_P2tT2tT__MP)(void (*__anonymous_object648)(), void *__anonymous_object649, void *__anonymous_object650), __attribute__ ((unused)) void (*_adapterF2tT_P2tT2tT_P_MP)(void (*__anonymous_object651)(), __attribute__ ((unused)) void *___retval__operator_assign__2tT_1, void *__anonymous_object652, void *__anonymous_object653), __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__F2tT_2tT2tT__1)(void *__anonymous_object654, void *__anonymous_object655), __attribute__ ((unused)) void (*___constructor__F_2tT__1)(void *__anonymous_object656), __attribute__ ((unused)) void (*___constructor__F_2tT2tT__1)(void *__anonymous_object657, void *__anonymous_object658), __attribute__ ((unused)) void (*___destructor__F_2tT__1)(void *__anonymous_object659), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype2tT__1)(void *__anonymous_object660, void *__anonymous_object661), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object662), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object663), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object664, _Bool __anonymous_object665), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object666), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object667, const char *__anonymous_object668), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object669), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object670, _Bool __anonymous_object671), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object672), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object673), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object674), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object675), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object676), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object677, const char *__anonymous_object678), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object679), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object680, const char *__anonymous_object681), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object682), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object683), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object684, const char *__anonymous_object685, unsigned long int __anonymous_object686), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object687, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype7tParams__1)(void *__anonymous_object688, void *__anonymous_object689), void *__os__7tostype_1, void *__arg__2tT_1, void *__rest__7tParams_1);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object690), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object691), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object692, _Bool __anonymous_object693), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object694), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object695, const char *__anonymous_object696), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object697), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object698, _Bool __anonymous_object699), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object700), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object701), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object702), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object703), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object704), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object705, const char *__anonymous_object706), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object707), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object708, const char *__anonymous_object709), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object710), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object711), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object712, const char *__anonymous_object713, unsigned long int __anonymous_object714), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object715, const char *__fmt__PCc_1, ...), void *__anonymous_object716, void *(*__anonymous_object717)(void *__anonymous_object718));
+void *__endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object719), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object720), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object721, _Bool __anonymous_object722), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object723), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object724, const char *__anonymous_object725), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object726), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object727, _Bool __anonymous_object728), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object729), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object730), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object731), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object732), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object733), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object734, const char *__anonymous_object735), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object736), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object737, const char *__anonymous_object738), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object739), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object740), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object741, const char *__anonymous_object742, unsigned long int __anonymous_object743), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object744, const char *__fmt__PCc_1, ...), void *__anonymous_object745);
+void *__sep__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object746), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object747), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object748, _Bool __anonymous_object749), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object750), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object751, const char *__anonymous_object752), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object753), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object754, _Bool __anonymous_object755), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object756), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object757), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object758), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object759), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object760), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object761, const char *__anonymous_object762), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object763), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object764, const char *__anonymous_object765), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object766), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object767), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object768, const char *__anonymous_object769, unsigned long int __anonymous_object770), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object771, const char *__fmt__PCc_1, ...), void *__anonymous_object772);
+void *__sepTuple__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object773), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object774), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object775, _Bool __anonymous_object776), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object777), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object778, const char *__anonymous_object779), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object780), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object781, _Bool __anonymous_object782), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object783), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object784), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object785), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object786), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object787), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object788, const char *__anonymous_object789), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object790), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object791, const char *__anonymous_object792), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object793), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object794), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object795, const char *__anonymous_object796, unsigned long int __anonymous_object797), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object798, const char *__fmt__PCc_1, ...), void *__anonymous_object799);
+void *__sepOn__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object800), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object801), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object802, _Bool __anonymous_object803), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object804), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object805, const char *__anonymous_object806), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object807), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object808, _Bool __anonymous_object809), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object810), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object811), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object812), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object813), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object814), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object815, const char *__anonymous_object816), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object817), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object818, const char *__anonymous_object819), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object820), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object821), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object822, const char *__anonymous_object823, unsigned long int __anonymous_object824), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object825, const char *__fmt__PCc_1, ...), void *__anonymous_object826);
+void *__sepOff__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object827), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object828), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object829, _Bool __anonymous_object830), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object831), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object832, const char *__anonymous_object833), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object834), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object835, _Bool __anonymous_object836), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object837), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object838), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object839), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object840), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object841), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object842, const char *__anonymous_object843), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object844), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object845, const char *__anonymous_object846), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object847), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object848), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object849, const char *__anonymous_object850, unsigned long int __anonymous_object851), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object852, const char *__fmt__PCc_1, ...), void *__anonymous_object853);
+void *__sepDisable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object854), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object855), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object856, _Bool __anonymous_object857), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object858), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object859, const char *__anonymous_object860), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object861), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object862, _Bool __anonymous_object863), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object864), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object865), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object866), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object867), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object868), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object869, const char *__anonymous_object870), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object871), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object872, const char *__anonymous_object873), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object874), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object875), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object876, const char *__anonymous_object877, unsigned long int __anonymous_object878), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object879, const char *__fmt__PCc_1, ...), void *__anonymous_object880);
+void *__sepEnable__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object881), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object882), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object883, _Bool __anonymous_object884), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object885), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object886, const char *__anonymous_object887), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object888), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object889, _Bool __anonymous_object890), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object891), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object892), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object893), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object894), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object895), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object896, const char *__anonymous_object897), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object898), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object899, const char *__anonymous_object900), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object901), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object902), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object903, const char *__anonymous_object904, unsigned long int __anonymous_object905), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object906, const char *__fmt__PCc_1, ...), void *__anonymous_object907);
+void __write__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object908)(), void *__anonymous_object909), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object910)(), void *__anonymous_object911, void *__anonymous_object912), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object913)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object914), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object915)(), void *__anonymous_object916, void *__anonymous_object917), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object918)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object919, void *__anonymous_object920), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object921)(), void *__anonymous_object922, void *__anonymous_object923), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object924)(), void *__anonymous_object925, void *__anonymous_object926), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object927)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object928, void *__anonymous_object929), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object930, void *__anonymous_object931), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object932), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object933, void *__anonymous_object934), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object935), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object936, void *__anonymous_object937), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object938), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object939), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object940, _Bool __anonymous_object941), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object942), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object943, const char *__anonymous_object944), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object945), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object946, _Bool __anonymous_object947), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object948), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object949), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object950), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object951), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object952), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object953, const char *__anonymous_object954), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object955), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object956, const char *__anonymous_object957), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object958), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object959), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object960, const char *__anonymous_object961, unsigned long int __anonymous_object962), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object963, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object964, void *__anonymous_object965), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object966), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object967, void *__anonymous_object968), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object969), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object970), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object971), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object972, void *__anonymous_object973), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object974, void *__anonymous_object975), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object976), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);
+void __write_reverse__A0_3_0_0____operator_assign__Fd1_d1d1____constructor__F_d1____constructor__F_d1d1____destructor__F_d1____operator_bitor__Fd0_d0d1___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc____operator_assign__Fd2_d2d2____constructor__F_d2____constructor__F_d2d2____destructor__F_d2____operator_preincr__Fd2_d2____operator_predecr__Fd2_d2____operator_equal__Fi_d2d2____operator_notequal__Fi_d2d2____operator_deref__Fd1_d2__F_d2d2d0__1(__attribute__ ((unused)) void *(*_adapterFP9telt_type_14titerator_type_M_P)(void (*__anonymous_object977)(), void *__anonymous_object978), __attribute__ ((unused)) signed int (*_adapterFi_14titerator_type14titerator_type_M_PP)(void (*__anonymous_object979)(), void *__anonymous_object980, void *__anonymous_object981), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type_P_M)(void (*__anonymous_object982)(), __attribute__ ((unused)) void *___retval__operator_preincr__14titerator_type_1, void *__anonymous_object983), __attribute__ ((unused)) void (*_adapterF_P14titerator_type14titerator_type__MP)(void (*__anonymous_object984)(), void *__anonymous_object985, void *__anonymous_object986), __attribute__ ((unused)) void (*_adapterF14titerator_type_P14titerator_type14titerator_type_P_MP)(void (*__anonymous_object987)(), __attribute__ ((unused)) void *___retval__operator_assign__14titerator_type_1, void *__anonymous_object988, void *__anonymous_object989), __attribute__ ((unused)) void *(*_adapterFP7tostype_P7tostype9telt_type_M_MP)(void (*__anonymous_object990)(), void *__anonymous_object991, void *__anonymous_object992), __attribute__ ((unused)) void (*_adapterF_P9telt_type9telt_type__MP)(void (*__anonymous_object993)(), void *__anonymous_object994, void *__anonymous_object995), __attribute__ ((unused)) void (*_adapterF9telt_type_P9telt_type9telt_type_P_MP)(void (*__anonymous_object996)(), __attribute__ ((unused)) void *___retval__operator_assign__9telt_type_1, void *__anonymous_object997, void *__anonymous_object998), __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__F9telt_type_9telt_type9telt_type__1)(void *__anonymous_object999, void *__anonymous_object1000), __attribute__ ((unused)) void (*___constructor__F_9telt_type__1)(void *__anonymous_object1001), __attribute__ ((unused)) void (*___constructor__F_9telt_type9telt_type__1)(void *__anonymous_object1002, void *__anonymous_object1003), __attribute__ ((unused)) void (*___destructor__F_9telt_type__1)(void *__anonymous_object1004), __attribute__ ((unused)) void *(*___operator_bitor__F7tostype_7tostype9telt_type__1)(void *__anonymous_object1005, void *__anonymous_object1006), __attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1007), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1008), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1009, _Bool __anonymous_object1010), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1011), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1012, const char *__anonymous_object1013), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1014), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1015, _Bool __anonymous_object1016), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1017), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1018), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1019), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1020), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1021), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1022, const char *__anonymous_object1023), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1024), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1025, const char *__anonymous_object1026), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1027), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1028), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1029, const char *__anonymous_object1030, unsigned long int __anonymous_object1031), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1032, const char *__fmt__PCc_1, ...), __attribute__ ((unused)) void *(*___operator_assign__F14titerator_type_14titerator_type14titerator_type__1)(void *__anonymous_object1033, void *__anonymous_object1034), __attribute__ ((unused)) void (*___constructor__F_14titerator_type__1)(void *__anonymous_object1035), __attribute__ ((unused)) void (*___constructor__F_14titerator_type14titerator_type__1)(void *__anonymous_object1036, void *__anonymous_object1037), __attribute__ ((unused)) void (*___destructor__F_14titerator_type__1)(void *__anonymous_object1038), __attribute__ ((unused)) void *(*___operator_preincr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1039), __attribute__ ((unused)) void *(*___operator_predecr__F14titerator_type_14titerator_type__1)(void *__anonymous_object1040), __attribute__ ((unused)) signed int (*___operator_equal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1041, void *__anonymous_object1042), __attribute__ ((unused)) signed int (*___operator_notequal__Fi_14titerator_type14titerator_type__1)(void *__anonymous_object1043, void *__anonymous_object1044), __attribute__ ((unused)) void *(*___operator_deref__F9telt_type_14titerator_type__1)(void *__anonymous_object1045), void *__begin__14titerator_type_1, void *__end__14titerator_type_1, void *__os__7tostype_1);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0b__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1046), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1047), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1048, char *__anonymous_object1049, unsigned long int __anonymous_object1050), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1051, char __anonymous_object1052), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1053, const char *__fmt__PCc_1, ...), void *__anonymous_object1054, _Bool *__anonymous_object1055);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0c__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1056), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1057), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1058, char *__anonymous_object1059, unsigned long int __anonymous_object1060), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1061, char __anonymous_object1062), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1063, const char *__fmt__PCc_1, ...), void *__anonymous_object1064, char *__anonymous_object1065);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Sc__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1066), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1067), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1068, char *__anonymous_object1069, unsigned long int __anonymous_object1070), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1071, char __anonymous_object1072), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1073, const char *__fmt__PCc_1, ...), void *__anonymous_object1074, signed char *__anonymous_object1075);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Uc__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1076), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1077), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1078, char *__anonymous_object1079, unsigned long int __anonymous_object1080), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1081, char __anonymous_object1082), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1083, const char *__fmt__PCc_1, ...), void *__anonymous_object1084, unsigned char *__anonymous_object1085);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0s__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1086), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1087), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1088, char *__anonymous_object1089, unsigned long int __anonymous_object1090), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1091, char __anonymous_object1092), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1093, const char *__fmt__PCc_1, ...), void *__anonymous_object1094, signed short int *__anonymous_object1095);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Us__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1096), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1097), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1098, char *__anonymous_object1099, unsigned long int __anonymous_object1100), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1101, char __anonymous_object1102), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1103, const char *__fmt__PCc_1, ...), void *__anonymous_object1104, unsigned short int *__anonymous_object1105);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0i__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1106), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1107), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1108, char *__anonymous_object1109, unsigned long int __anonymous_object1110), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1111, char __anonymous_object1112), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1113, const char *__fmt__PCc_1, ...), void *__anonymous_object1114, signed int *__anonymous_object1115);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Ui__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1116), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1117), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1118, char *__anonymous_object1119, unsigned long int __anonymous_object1120), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1121, char __anonymous_object1122), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1123, const char *__fmt__PCc_1, ...), void *__anonymous_object1124, unsigned int *__anonymous_object1125);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0l__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1126), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1127), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1128, char *__anonymous_object1129, unsigned long int __anonymous_object1130), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1131, char __anonymous_object1132), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1133, const char *__fmt__PCc_1, ...), void *__anonymous_object1134, signed long int *__anonymous_object1135);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0q__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1136), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1137), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1138, char *__anonymous_object1139, unsigned long int __anonymous_object1140), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1141, char __anonymous_object1142), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1143, const char *__fmt__PCc_1, ...), void *__anonymous_object1144, signed long long int *__anonymous_object1145);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Ul__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1146), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1147), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1148, char *__anonymous_object1149, unsigned long int __anonymous_object1150), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1151, char __anonymous_object1152), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1153, const char *__fmt__PCc_1, ...), void *__anonymous_object1154, unsigned long int *__anonymous_object1155);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Uq__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1156), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1157), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1158, char *__anonymous_object1159, unsigned long int __anonymous_object1160), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1161, char __anonymous_object1162), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1163, const char *__fmt__PCc_1, ...), void *__anonymous_object1164, unsigned long long int *__anonymous_object1165);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0f__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1166), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1167), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1168, char *__anonymous_object1169, unsigned long int __anonymous_object1170), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1171, char __anonymous_object1172), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1173, const char *__fmt__PCc_1, ...), void *__anonymous_object1174, float *__anonymous_object1175);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0d__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1176), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1177), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1178, char *__anonymous_object1179, unsigned long int __anonymous_object1180), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1181, char __anonymous_object1182), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1183, const char *__fmt__PCc_1, ...), void *__anonymous_object1184, double *__anonymous_object1185);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0r__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1186), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1187), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1188, char *__anonymous_object1189, unsigned long int __anonymous_object1190), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1191, char __anonymous_object1192), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1193, const char *__fmt__PCc_1, ...), void *__anonymous_object1194, long double *__anonymous_object1195);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Xf__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1196), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1197), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1198, char *__anonymous_object1199, unsigned long int __anonymous_object1200), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1201, char __anonymous_object1202), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1203, const char *__fmt__PCc_1, ...), void *__anonymous_object1204, float _Complex *__anonymous_object1205);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Xd__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1206), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1207), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1208, char *__anonymous_object1209, unsigned long int __anonymous_object1210), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1211, char __anonymous_object1212), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1213, const char *__fmt__PCc_1, ...), void *__anonymous_object1214, double _Complex *__anonymous_object1215);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Xr__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1216), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1217), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1218, char *__anonymous_object1219, unsigned long int __anonymous_object1220), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1221, char __anonymous_object1222), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1223, const char *__fmt__PCc_1, ...), void *__anonymous_object1224, long double _Complex *__anonymous_object1225);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1226), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1227), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1228, char *__anonymous_object1229, unsigned long int __anonymous_object1230), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1231, char __anonymous_object1232), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1233, const char *__fmt__PCc_1, ...), void *__anonymous_object1234, void *(*__anonymous_object1235)(void *__anonymous_object1236));
+void *__endl__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d0__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1237), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1238), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1239, char *__anonymous_object1240, unsigned long int __anonymous_object1241), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1242, char __anonymous_object1243), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1244, const char *__fmt__PCc_1, ...), void *__is__7tistype_1);
 struct _Istream_cstrUC {
     char *__s__Pc_1;
 };
 static inline void ___constructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1);
 static inline void ___constructor__F_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 ___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) /* ?{} */);
+}
 static inline void ___constructor__F_R16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1) /* ?{} */);
+}
 static inline void ___destructor__F_R16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__R16s_Istream_cstrUC_1){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_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_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___destructor__F_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1);
+static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1);
+static inline void ___constructor__F_16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, char *__s__Pc_1);
+static inline void ___constructor__F_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1) /* ?{} */);
+}
+static inline void ___constructor__F_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1) /* ?{} */);
+}
+static inline void ___destructor__F_16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1) /* ^?{} */);
+}
+static inline struct _Istream_cstrUC ___operator_assign__F16s_Istream_cstrUC_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, struct _Istream_cstrUC ___src__16s_Istream_cstrUC_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), (*___dst__R16s_Istream_cstrUC_1)));
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1=___src__16s_Istream_cstrUC_1.__s__Pc_1));
+    ((void)___constructor__F_16s_Istream_cstrUC16s_Istream_cstrUC_autogen___1((&___ret__16s_Istream_cstrUC_1), (*___dst__16s_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){
     ((void)((*___dst__R16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+static inline void ___constructor__F_16s_Istream_cstrUCPc_autogen___1(struct _Istream_cstrUC *___dst__16s_Istream_cstrUC_1, char *__s__Pc_1){
+    ((void)((*___dst__16s_Istream_cstrUC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+}
 struct _Istream_cstrUC __cstr__F16s_Istream_cstrUC_Pc__1(char *__anonymous_object1245);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1246), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1247), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1248, char *__anonymous_object1249, unsigned long int __anonymous_object1250), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1251, char __anonymous_object1252), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1253, const char *__fmt__PCc_1, ...), void *__anonymous_object1254, struct _Istream_cstrUC __anonymous_object1255);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d016s_Istream_cstrUC__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1246), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1247), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1248, char *__anonymous_object1249, unsigned long int __anonymous_object1250), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1251, char __anonymous_object1252), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1253, const char *__fmt__PCc_1, ...), void *__anonymous_object1254, struct _Istream_cstrUC __anonymous_object1255);
 struct _Istream_cstrC {
     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);
 static inline void ___constructor__F_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 ___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).__size__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_R15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_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) /* ?{} */);
+}
 static inline void ___destructor__F_R15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__R15s_Istream_cstrC_1){
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1) /* ^?{} */);
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_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_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1);
+static inline void ___constructor__F_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___destructor__F_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1);
+static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1);
+static inline void ___constructor__F_15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1);
+static inline void ___constructor__F_15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1);
+static inline void ___constructor__F_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1) /* ?{} */);
+}
+static inline void ___destructor__F_15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1) /* ^?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1) /* ^?{} */);
+}
+static inline struct _Istream_cstrC ___operator_assign__F15s_Istream_cstrC_15s_Istream_cstrC15s_Istream_cstrC_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, struct _Istream_cstrC ___src__15s_Istream_cstrC_1){
     struct _Istream_cstrC ___ret__15s_Istream_cstrC_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), (*___dst__R15s_Istream_cstrC_1)));
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=___src__15s_Istream_cstrC_1.__s__Pc_1));
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1=___src__15s_Istream_cstrC_1.__size__i_1));
+    ((void)___constructor__F_15s_Istream_cstrC15s_Istream_cstrC_autogen___1((&___ret__15s_Istream_cstrC_1), (*___dst__15s_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)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_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){
     ((void)((*___dst__R15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
     ((void)((*___dst__R15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */);
+static inline void ___constructor__F_15s_Istream_cstrCPc_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1) /* ?{} */);
+}
+static inline void ___constructor__F_15s_Istream_cstrCPci_autogen___1(struct _Istream_cstrC *___dst__15s_Istream_cstrC_1, char *__s__Pc_1, signed int __size__i_1){
+    ((void)((*___dst__15s_Istream_cstrC_1).__s__Pc_1=__s__Pc_1) /* ?{} */);
+    ((void)((*___dst__15s_Istream_cstrC_1).__size__i_1=__size__i_1) /* ?{} */);
+}
 struct _Istream_cstrC __cstr__F15s_Istream_cstrC_Pci__1(char *__anonymous_object1256, signed int __size__i_1);
 void *___operator_bitor__A0_1_0_0___fail__PFi_Rd0___eof__PFi_Rd0___open__PF_Rd0PCc___close__PF_Rd0___read__PFRd0_Rd0PcUl___ungetc__PFRd0_Rd0c___fmt__PFi_Rd0PCc__FRd0_Rd015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__PFi_R7tistype__1)(void *__anonymous_object1257), __attribute__ ((unused)) signed int (*__eof__PFi_R7tistype__1)(void *__anonymous_object1258), __attribute__ ((unused)) void (*__open__PF_R7tistypePCc__1)(void *__is__R7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tistype__1)(void *__is__R7tistype_1), __attribute__ ((unused)) void *(*__read__PFR7tistype_R7tistypePcUl__1)(void *__anonymous_object1259, char *__anonymous_object1260, unsigned long int __anonymous_object1261), __attribute__ ((unused)) void *(*__ungetc__PFR7tistype_R7tistypec__1)(void *__anonymous_object1262, char __anonymous_object1263), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tistypePCc__1)(void *__anonymous_object1264, const char *__fmt__PCc_1, ...), void *__anonymous_object1265, struct _Istream_cstrC __anonymous_object1266);
+void *___operator_bitor__A0_1_0_0___fail__Fi_d0___eof__Fi_d0___open__F_d0PCc___close__F_d0___read__Fd0_d0PcUl___ungetc__Fd0_d0c___fmt__Fi_d0PCc__Fd0_d015s_Istream_cstrC__1(__attribute__ ((unused)) signed int (*__fail__Fi_7tistype__1)(void *__anonymous_object1257), __attribute__ ((unused)) signed int (*__eof__Fi_7tistype__1)(void *__anonymous_object1258), __attribute__ ((unused)) void (*__open__F_7tistypePCc__1)(void *__is__7tistype_1, const char *__name__PCc_1), __attribute__ ((unused)) void (*__close__F_7tistype__1)(void *__is__7tistype_1), __attribute__ ((unused)) void *(*__read__F7tistype_7tistypePcUl__1)(void *__anonymous_object1259, char *__anonymous_object1260, unsigned long int __anonymous_object1261), __attribute__ ((unused)) void *(*__ungetc__F7tistype_7tistypec__1)(void *__anonymous_object1262, char __anonymous_object1263), __attribute__ ((unused)) signed int (*__fmt__Fi_7tistypePCc__1)(void *__anonymous_object1264, const char *__fmt__PCc_1, ...), void *__anonymous_object1265, struct _Istream_cstrC __anonymous_object1266);
 struct Duration {
     signed long long int __tv__q_1;
 };
 static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
 static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
 static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1);
 static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1);
 static inline void ___constructor__F_R9sDurationq_autogen___1(struct Duration *___dst__R9sDuration_1, signed long long int __tv__q_1);
 static inline void ___constructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     ((void)((*___dst__R9sDuration_1).__tv__q_1) /* ?{} */);
+}
 static inline void ___constructor__F_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
     ((void)((*___dst__R9sDuration_1).__tv__q_1=___src__9sDuration_1.__tv__q_1) /* ?{} */);
+}
 static inline void ___destructor__F_R9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1){
     ((void)((*___dst__R9sDuration_1).__tv__q_1) /* ^?{} */);
+}
 static inline struct Duration ___operator_assign__F9sDuration_R9sDuration9sDuration_autogen___1(struct Duration *___dst__R9sDuration_1, struct Duration ___src__9sDuration_1){
+static inline void ___constructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1);
+static inline void ___constructor__F_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1);
+static inline void ___destructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1);
+static inline struct Duration ___operator_assign__F9sDuration_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1);
+static inline void ___constructor__F_9sDurationq_autogen___1(struct Duration *___dst__9sDuration_1, signed long long int __tv__q_1);
+static inline void ___constructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1){
+    ((void)((*___dst__9sDuration_1).__tv__q_1) /* ?{} */);
+}
+static inline void ___constructor__F_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1){
+    ((void)((*___dst__9sDuration_1).__tv__q_1=___src__9sDuration_1.__tv__q_1) /* ?{} */);
+}
+static inline void ___destructor__F_9sDuration_autogen___1(struct Duration *___dst__9sDuration_1){
+    ((void)((*___dst__9sDuration_1).__tv__q_1) /* ^?{} */);
+}
+static inline struct Duration ___operator_assign__F9sDuration_9sDuration9sDuration_autogen___1(struct Duration *___dst__9sDuration_1, struct Duration ___src__9sDuration_1){
     struct Duration ___ret__9sDuration_1;
     ((void)((*___dst__R9sDuration_1).__tv__q_1=___src__9sDuration_1.__tv__q_1));
     ((void)___constructor__F_R9sDuration9sDuration_autogen___1((&___ret__9sDuration_1), (*___dst__R9sDuration_1)));
+    ((void)((*___dst__9sDuration_1).__tv__q_1=___src__9sDuration_1.__tv__q_1));
+    ((void)___constructor__F_9sDuration9sDuration_autogen___1((&___ret__9sDuration_1), (*___dst__9sDuration_1)));
     return ___ret__9sDuration_1;
+}
 static inline void ___constructor__F_R9sDurationq_autogen___1(struct Duration *___dst__R9sDuration_1, signed long long int __tv__q_1){
     ((void)((*___dst__R9sDuration_1).__tv__q_1=__tv__q_1) /* ?{} */);
+}
 static inline void ___constructor__F_R9sDuration__1(struct Duration *__dur__R9sDuration_1){
     ((void)((*__dur__R9sDuration_1).__tv__q_1) /* ?{} */);
     ((void)((*__dur__R9sDuration_1).__tv__q_1=((signed long long int )0)));
+}
 static inline void ___constructor__F_R9sDurationZ__1(struct Duration *__dur__R9sDuration_1, long int __anonymous_object1267){
     ((void)((*__dur__R9sDuration_1).__tv__q_1) /* ?{} */);
     ((void)((*__dur__R9sDuration_1).__tv__q_1=((signed long long int )0)));
+static inline void ___constructor__F_9sDurationq_autogen___1(struct Duration *___dst__9sDuration_1, signed long long int __tv__q_1){
+    ((void)((*___dst__9sDuration_1).__tv__q_1=__tv__q_1) /* ?{} */);
+}
+static inline void ___constructor__F_9sDuration__1(struct Duration *__dur__9sDuration_1){
+    ((void)((*__dur__9sDuration_1).__tv__q_1) /* ?{} */);
+    ((void)((*__dur__9sDuration_1).__tv__q_1=((signed long long int )0)));
+}
+static inline void ___constructor__F_9sDurationZ__1(struct Duration *__dur__9sDuration_1, long int __anonymous_object1267){
+    ((void)((*__dur__9sDuration_1).__tv__q_1) /* ?{} */);
+    ((void)((*__dur__9sDuration_1).__tv__q_1=((signed long long int )0)));
+}
 struct Time {
     unsigned long long int __tv__Uq_1;
 };
 static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
 static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
 static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1);
 static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1);
 static inline void ___constructor__F_R5sTimeUq_autogen___1(struct Time *___dst__R5sTime_1, unsigned long long int __tv__Uq_1);
 static inline void ___constructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     ((void)((*___dst__R5sTime_1).__tv__Uq_1) /* ?{} */);
+}
 static inline void ___constructor__F_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
     ((void)((*___dst__R5sTime_1).__tv__Uq_1=___src__5sTime_1.__tv__Uq_1) /* ?{} */);
+}
 static inline void ___destructor__F_R5sTime_autogen___1(struct Time *___dst__R5sTime_1){
     ((void)((*___dst__R5sTime_1).__tv__Uq_1) /* ^?{} */);
+}
 static inline struct Time ___operator_assign__F5sTime_R5sTime5sTime_autogen___1(struct Time *___dst__R5sTime_1, struct Time ___src__5sTime_1){
+static inline void ___constructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1);
+static inline void ___constructor__F_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1);
+static inline void ___destructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1);
+static inline struct Time ___operator_assign__F5sTime_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1);
+static inline void ___constructor__F_5sTimeUq_autogen___1(struct Time *___dst__5sTime_1, unsigned long long int __tv__Uq_1);
+static inline void ___constructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1){
+    ((void)((*___dst__5sTime_1).__tv__Uq_1) /* ?{} */);
+}
+static inline void ___constructor__F_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1){
+    ((void)((*___dst__5sTime_1).__tv__Uq_1=___src__5sTime_1.__tv__Uq_1) /* ?{} */);
+}
+static inline void ___destructor__F_5sTime_autogen___1(struct Time *___dst__5sTime_1){
+    ((void)((*___dst__5sTime_1).__tv__Uq_1) /* ^?{} */);
+}
+static inline struct Time ___operator_assign__F5sTime_5sTime5sTime_autogen___1(struct Time *___dst__5sTime_1, struct Time ___src__5sTime_1){
     struct Time ___ret__5sTime_1;
     ((void)((*___dst__R5sTime_1).__tv__Uq_1=___src__5sTime_1.__tv__Uq_1));
     ((void)___constructor__F_R5sTime5sTime_autogen___1((&___ret__5sTime_1), (*___dst__R5sTime_1)));
+    ((void)((*___dst__5sTime_1).__tv__Uq_1=___src__5sTime_1.__tv__Uq_1));
+    ((void)___constructor__F_5sTime5sTime_autogen___1((&___ret__5sTime_1), (*___dst__5sTime_1)));
     return ___ret__5sTime_1;
+}
 static inline void ___constructor__F_R5sTimeUq_autogen___1(struct Time *___dst__R5sTime_1, unsigned long long int __tv__Uq_1){
     ((void)((*___dst__R5sTime_1).__tv__Uq_1=__tv__Uq_1) /* ?{} */);
+}
 static inline void ___constructor__F_R5sTime__1(struct Time *__time__R5sTime_1){
     ((void)((*__time__R5sTime_1).__tv__Uq_1) /* ?{} */);
     ((void)((*__time__R5sTime_1).__tv__Uq_1=((unsigned long long int )0)));
+}
 static inline void ___constructor__F_R5sTimeZ__1(struct Time *__time__R5sTime_1, long int __anonymous_object1268){
     ((void)((*__time__R5sTime_1).__tv__Uq_1) /* ?{} */);
     ((void)((*__time__R5sTime_1).__tv__Uq_1=((unsigned long long int )0)));
+}
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd09sDuration__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1269), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1270), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1271, _Bool __anonymous_object1272), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1273), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1274, const char *__anonymous_object1275), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1276), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1277, _Bool __anonymous_object1278), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1279), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1280), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1281), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1282), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1283), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1284, const char *__anonymous_object1285), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1286), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1287, const char *__anonymous_object1288), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1289), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1290), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1291, const char *__anonymous_object1292, unsigned long int __anonymous_object1293), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1294, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Duration __dur__9sDuration_1);
 void *___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd05sTime__1(__attribute__ ((unused)) _Bool (*__sepPrt__PFb_R7tostype__1)(void *__anonymous_object1295), __attribute__ ((unused)) void (*__sepReset__PF_R7tostype__1)(void *__anonymous_object1296), __attribute__ ((unused)) void (*__sepReset__PF_R7tostypeb__1)(void *__anonymous_object1297, _Bool __anonymous_object1298), __attribute__ ((unused)) const char *(*__sepGetCur__PFPCc_R7tostype__1)(void *__anonymous_object1299), __attribute__ ((unused)) void (*__sepSetCur__PF_R7tostypePCc__1)(void *__anonymous_object1300, const char *__anonymous_object1301), __attribute__ ((unused)) _Bool (*__getNL__PFb_R7tostype__1)(void *__anonymous_object1302), __attribute__ ((unused)) void (*__setNL__PF_R7tostypeb__1)(void *__anonymous_object1303, _Bool __anonymous_object1304), __attribute__ ((unused)) void (*__sepOn__PF_R7tostype__1)(void *__anonymous_object1305), __attribute__ ((unused)) void (*__sepOff__PF_R7tostype__1)(void *__anonymous_object1306), __attribute__ ((unused)) _Bool (*__sepDisable__PFb_R7tostype__1)(void *__anonymous_object1307), __attribute__ ((unused)) _Bool (*__sepEnable__PFb_R7tostype__1)(void *__anonymous_object1308), __attribute__ ((unused)) const char *(*__sepGet__PFPCc_R7tostype__1)(void *__anonymous_object1309), __attribute__ ((unused)) void (*__sepSet__PF_R7tostypePCc__1)(void *__anonymous_object1310, const char *__anonymous_object1311), __attribute__ ((unused)) const char *(*__sepGetTuple__PFPCc_R7tostype__1)(void *__anonymous_object1312), __attribute__ ((unused)) void (*__sepSetTuple__PF_R7tostypePCc__1)(void *__anonymous_object1313, const char *__anonymous_object1314), __attribute__ ((unused)) signed int (*__fail__PFi_R7tostype__1)(void *__anonymous_object1315), __attribute__ ((unused)) signed int (*__flush__PFi_R7tostype__1)(void *__anonymous_object1316), __attribute__ ((unused)) void (*__open__PF_R7tostypePCcPCc__1)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__PF_R7tostype__1)(void *__os__R7tostype_1), __attribute__ ((unused)) void *(*__write__PFR7tostype_R7tostypePCcUl__1)(void *__anonymous_object1317, const char *__anonymous_object1318, unsigned long int __anonymous_object1319), __attribute__ ((unused)) signed int (*__fmt__PFi_R7tostypePCc__1)(void *__anonymous_object1320, const char *__fmt__PCc_1, ...), void *__os__R7tostype_1, struct Time __time__5sTime_1);
+static inline void ___constructor__F_5sTimeUq_autogen___1(struct Time *___dst__5sTime_1, unsigned long long int __tv__Uq_1){
+    ((void)((*___dst__5sTime_1).__tv__Uq_1=__tv__Uq_1) /* ?{} */);
+}
+static inline void ___constructor__F_5sTime__1(struct Time *__time__5sTime_1){
+    ((void)((*__time__5sTime_1).__tv__Uq_1) /* ?{} */);
+    ((void)((*__time__5sTime_1).__tv__Uq_1=((unsigned long long int )0)));
+}
+static inline void ___constructor__F_5sTimeZ__1(struct Time *__time__5sTime_1, long int __anonymous_object1268){
+    ((void)((*__time__5sTime_1).__tv__Uq_1) /* ?{} */);
+    ((void)((*__time__5sTime_1).__tv__Uq_1=((unsigned long long int )0)));
+}
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d09sDuration__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1269), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1270), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1271, _Bool __anonymous_object1272), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1273), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1274, const char *__anonymous_object1275), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1276), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1277, _Bool __anonymous_object1278), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1279), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1280), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1281), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1282), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1283), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1284, const char *__anonymous_object1285), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1286), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1287, const char *__anonymous_object1288), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1289), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1290), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1291, const char *__anonymous_object1292, unsigned long int __anonymous_object1293), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1294, const char *__fmt__PCc_1, ...), void *__os__7tostype_1, struct Duration __dur__9sDuration_1);
+void *___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d05sTime__1(__attribute__ ((unused)) _Bool (*__sepPrt__Fb_7tostype__1)(void *__anonymous_object1295), __attribute__ ((unused)) void (*__sepReset__F_7tostype__1)(void *__anonymous_object1296), __attribute__ ((unused)) void (*__sepReset__F_7tostypeb__1)(void *__anonymous_object1297, _Bool __anonymous_object1298), __attribute__ ((unused)) const char *(*__sepGetCur__FPCc_7tostype__1)(void *__anonymous_object1299), __attribute__ ((unused)) void (*__sepSetCur__F_7tostypePCc__1)(void *__anonymous_object1300, const char *__anonymous_object1301), __attribute__ ((unused)) _Bool (*__getNL__Fb_7tostype__1)(void *__anonymous_object1302), __attribute__ ((unused)) void (*__setNL__F_7tostypeb__1)(void *__anonymous_object1303, _Bool __anonymous_object1304), __attribute__ ((unused)) void (*__sepOn__F_7tostype__1)(void *__anonymous_object1305), __attribute__ ((unused)) void (*__sepOff__F_7tostype__1)(void *__anonymous_object1306), __attribute__ ((unused)) _Bool (*__sepDisable__Fb_7tostype__1)(void *__anonymous_object1307), __attribute__ ((unused)) _Bool (*__sepEnable__Fb_7tostype__1)(void *__anonymous_object1308), __attribute__ ((unused)) const char *(*__sepGet__FPCc_7tostype__1)(void *__anonymous_object1309), __attribute__ ((unused)) void (*__sepSet__F_7tostypePCc__1)(void *__anonymous_object1310, const char *__anonymous_object1311), __attribute__ ((unused)) const char *(*__sepGetTuple__FPCc_7tostype__1)(void *__anonymous_object1312), __attribute__ ((unused)) void (*__sepSetTuple__F_7tostypePCc__1)(void *__anonymous_object1313, const char *__anonymous_object1314), __attribute__ ((unused)) signed int (*__fail__Fi_7tostype__1)(void *__anonymous_object1315), __attribute__ ((unused)) signed int (*__flush__Fi_7tostype__1)(void *__anonymous_object1316), __attribute__ ((unused)) void (*__open__F_7tostypePCcPCc__1)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1), __attribute__ ((unused)) void (*__close__F_7tostype__1)(void *__os__7tostype_1), __attribute__ ((unused)) void *(*__write__F7tostype_7tostypePCcUl__1)(void *__anonymous_object1317, const char *__anonymous_object1318, unsigned long int __anonymous_object1319), __attribute__ ((unused)) signed int (*__fmt__Fi_7tostypePCc__1)(void *__anonymous_object1320, const char *__fmt__PCc_1, ...), void *__os__7tostype_1, struct Time __time__5sTime_1);
 enum __anonymous0 {
     __sepSize__C13e__anonymous0_1 = 16,
 …
     char __tupleSeparator__A0c_1[((unsigned int )__sepSize__C13e__anonymous0_1)];
 };
 static inline void ___constructor__F_R9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1);
 static inline void ___constructor__F_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1);
 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).__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+static inline void ___constructor__F_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1);
+static inline void ___constructor__F_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___destructor__F_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1);
+static inline struct ofstream ___operator_assign__F9sofstream_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1);
+static inline void ___constructor__F_9sofstreamPv_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_9sofstreamPvb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1);
+static inline void ___constructor__F_9sofstreamPvbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1);
+static inline void ___constructor__F_9sofstreamPvbbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1);
+static inline void ___constructor__F_9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__9sofstream_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_9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__9sofstream_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_9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__9sofstream_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_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index0 = 0;
         for (;(_index0<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index0))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index0]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index0]) /* ?{} */);
+        }
 …
         signed int _index1 = 0;
         for (;(_index1<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index1))) {
             ((void)((*___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).__file__Pv_1=___src__9sofstream_1.__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index1]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=___src__9sofstream_1.__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index2 = 0;
         for (;(_index2<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index2))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index2]=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index2]=___src__9sofstream_1.__separator__A0c_1[_index2]) /* ?{} */);
+        }
 …
         signed int _index3 = 0;
         for (;(_index3<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index3))) {
             ((void)((*___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){
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index3]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index3]) /* ?{} */);
+        }
+    }
+}
+static inline void ___destructor__F_9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1){
+    {
         signed int _index4 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index4>=0);((void)(--_index4))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index4]) /* ^?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index4]) /* ^?{} */);
+        }
 …
         signed int _index5 = (((signed int )__sepSize__C13e__anonymous0_1)-1);
         for (;(_index5>=0);((void)(--_index5))) {
             ((void)((*___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).__sepOnOff__b_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1) /* ^?{} */);
     ((void)((*___dst__R9sofstream_1).__file__Pv_1) /* ^?{} */);
+}
 static inline struct ofstream ___operator_assign__F9sofstream_R9sofstream9sofstream_autogen___1(struct ofstream *___dst__R9sofstream_1, struct ofstream ___src__9sofstream_1){
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index5]) /* ^?{} */);
+        }
+    }
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1) /* ^?{} */);
+    ((void)((*___dst__9sofstream_1).__file__Pv_1) /* ^?{} */);
+}
+static inline struct ofstream ___operator_assign__F9sofstream_9sofstream9sofstream_autogen___1(struct ofstream *___dst__9sofstream_1, struct ofstream ___src__9sofstream_1){
     struct ofstream ___ret__9sofstream_1;
     ((void)((*___dst__R9sofstream_1).__file__Pv_1=___src__9sofstream_1.__file__Pv_1));
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1));
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1));
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1));
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=___src__9sofstream_1.__file__Pv_1));
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=___src__9sofstream_1.__sepDefault__b_1));
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=___src__9sofstream_1.__sepOnOff__b_1));
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=___src__9sofstream_1.__sawNL__b_1));
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=___src__9sofstream_1.__sepCur__PCc_1));
+    {
         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]));
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index6]=___src__9sofstream_1.__separator__A0c_1[_index6]));
+        }
 …
         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), (*___dst__R9sofstream_1)));
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index7]=___src__9sofstream_1.__tupleSeparator__A0c_1[_index7]));
+        }
+    }
+    ((void)___constructor__F_9sofstream9sofstream_autogen___1((&___ret__9sofstream_1), (*___dst__9sofstream_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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+static inline void ___constructor__F_9sofstreamPv_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index8 = 0;
         for (;(_index8<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index8))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index8]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index8]) /* ?{} */);
+        }
 …
         signed int _index9 = 0;
         for (;(_index9<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index9))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index9]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index10 = 0;
         for (;(_index10<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index10))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index10]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index10]) /* ?{} */);
+        }
 …
         signed int _index11 = 0;
         for (;(_index11<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index11))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index11]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index12 = 0;
         for (;(_index12<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index12))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index12]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index12]) /* ?{} */);
+        }
 …
         signed int _index13 = 0;
         for (;(_index13<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index13))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index13]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbb_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index14 = 0;
         for (;(_index14<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index14))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index14]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index14]) /* ?{} */);
+        }
 …
         signed int _index15 = 0;
         for (;(_index15<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index15))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index15]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbbPCc_autogen___1(struct ofstream *___dst__9sofstream_1, void *__file__Pv_1, _Bool __sepDefault__b_1, _Bool __sepOnOff__b_1, _Bool __sawNL__b_1, const char *__sepCur__PCc_1){
+    ((void)((*___dst__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index16 = 0;
         for (;(_index16<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index16))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index16]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index16]) /* ?{} */);
+        }
 …
         signed int _index17 = 0;
         for (;(_index17<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index17))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index17]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbbPCcA0c_autogen___1(struct ofstream *___dst__9sofstream_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__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index18 = 0;
         for (;(_index18<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index18))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index18]=__separator__A0c_1[_index18]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index18]=__separator__A0c_1[_index18]) /* ?{} */);
+        }
 …
         signed int _index19 = 0;
         for (;(_index19<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index19))) {
             ((void)((*___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).__file__Pv_1=__file__Pv_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
     ((void)((*___dst__R9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index19]) /* ?{} */);
+        }
+    }
+}
+static inline void ___constructor__F_9sofstreamPvbbbPCcA0cA0c_autogen___1(struct ofstream *___dst__9sofstream_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__9sofstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepDefault__b_1=__sepDefault__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepOnOff__b_1=__sepOnOff__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sawNL__b_1=__sawNL__b_1) /* ?{} */);
+    ((void)((*___dst__9sofstream_1).__sepCur__PCc_1=__sepCur__PCc_1) /* ?{} */);
+    {
         signed int _index20 = 0;
         for (;(_index20<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index20))) {
             ((void)((*___dst__R9sofstream_1).__separator__A0c_1[_index20]=__separator__A0c_1[_index20]) /* ?{} */);
+            ((void)((*___dst__9sofstream_1).__separator__A0c_1[_index20]=__separator__A0c_1[_index20]) /* ?{} */);
+        }
 …
         signed int _index21 = 0;
         for (;(_index21<((signed int )__sepSize__C13e__anonymous0_1));((void)(++_index21))) {
             ((void)((*___dst__R9sofstream_1).__tupleSeparator__A0c_1[_index21]=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
+        }
+    }
+}
 _Bool __sepPrt__Fb_R9sofstream__1(struct ofstream *__anonymous_object1321);
 void __sepReset__F_R9sofstream__1(struct ofstream *__anonymous_object1322);
 void __sepReset__F_R9sofstreamb__1(struct ofstream *__anonymous_object1323, _Bool __anonymous_object1324);
 const char *__sepGetCur__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1325);
 void __sepSetCur__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1326, const char *__anonymous_object1327);
 _Bool __getNL__Fb_R9sofstream__1(struct ofstream *__anonymous_object1328);
 void __setNL__F_R9sofstreamb__1(struct ofstream *__anonymous_object1329, _Bool __anonymous_object1330);
 void __sepOn__F_R9sofstream__1(struct ofstream *__anonymous_object1331);
 void __sepOff__F_R9sofstream__1(struct ofstream *__anonymous_object1332);
 _Bool __sepDisable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1333);
 _Bool __sepEnable__Fb_R9sofstream__1(struct ofstream *__anonymous_object1334);
 const char *__sepGet__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1335);
 void __sepSet__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1336, const char *__anonymous_object1337);
 const char *__sepGetTuple__FPCc_R9sofstream__1(struct ofstream *__anonymous_object1338);
 void __sepSetTuple__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1339, const char *__anonymous_object1340);
 signed int __fail__Fi_R9sofstream__1(struct ofstream *__anonymous_object1341);
 signed int __flush__Fi_R9sofstream__1(struct ofstream *__anonymous_object1342);
 void __open__F_R9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1343, const char *__name__PCc_1, const char *__mode__PCc_1);
 void __open__F_R9sofstreamPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1);
 void __close__F_R9sofstream__1(struct ofstream *__anonymous_object1345);
 struct ofstream *__write__FR9sofstream_R9sofstreamPCcUl__1(struct ofstream *__anonymous_object1346, const char *__data__PCc_1, unsigned long int __size__Ul_1);
 signed int __fmt__Fi_R9sofstreamPCc__1(struct ofstream *__anonymous_object1347, const char *__fmt__PCc_1, ...);
 void ___constructor__F_R9sofstream__1(struct ofstream *__os__R9sofstream_1);
 void ___constructor__F_R9sofstreamPCcPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
 void ___constructor__F_R9sofstreamPCc__1(struct ofstream *__os__R9sofstream_1, const char *__name__PCc_1);
 extern struct ofstream *__sout__R9sofstream_1;
 extern struct ofstream *__serr__R9sofstream_1;
+            ((void)((*___dst__9sofstream_1).__tupleSeparator__A0c_1[_index21]=__tupleSeparator__A0c_1[_index21]) /* ?{} */);
+        }
+    }
+}
+_Bool __sepPrt__Fb_9sofstream__1(struct ofstream *__anonymous_object1321);
+void __sepReset__F_9sofstream__1(struct ofstream *__anonymous_object1322);
+void __sepReset__F_9sofstreamb__1(struct ofstream *__anonymous_object1323, _Bool __anonymous_object1324);
+const char *__sepGetCur__FPCc_9sofstream__1(struct ofstream *__anonymous_object1325);
+void __sepSetCur__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1326, const char *__anonymous_object1327);
+_Bool __getNL__Fb_9sofstream__1(struct ofstream *__anonymous_object1328);
+void __setNL__F_9sofstreamb__1(struct ofstream *__anonymous_object1329, _Bool __anonymous_object1330);
+void __sepOn__F_9sofstream__1(struct ofstream *__anonymous_object1331);
+void __sepOff__F_9sofstream__1(struct ofstream *__anonymous_object1332);
+_Bool __sepDisable__Fb_9sofstream__1(struct ofstream *__anonymous_object1333);
+_Bool __sepEnable__Fb_9sofstream__1(struct ofstream *__anonymous_object1334);
+const char *__sepGet__FPCc_9sofstream__1(struct ofstream *__anonymous_object1335);
+void __sepSet__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1336, const char *__anonymous_object1337);
+const char *__sepGetTuple__FPCc_9sofstream__1(struct ofstream *__anonymous_object1338);
+void __sepSetTuple__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1339, const char *__anonymous_object1340);
+signed int __fail__Fi_9sofstream__1(struct ofstream *__anonymous_object1341);
+signed int __flush__Fi_9sofstream__1(struct ofstream *__anonymous_object1342);
+void __open__F_9sofstreamPCcPCc__1(struct ofstream *__anonymous_object1343, const char *__name__PCc_1, const char *__mode__PCc_1);
+void __open__F_9sofstreamPCc__1(struct ofstream *__anonymous_object1344, const char *__name__PCc_1);
+void __close__F_9sofstream__1(struct ofstream *__anonymous_object1345);
+struct ofstream *__write__F9sofstream_9sofstreamPCcUl__1(struct ofstream *__anonymous_object1346, const char *__data__PCc_1, unsigned long int __size__Ul_1);
+signed int __fmt__Fi_9sofstreamPCc__1(struct ofstream *__anonymous_object1347, const char *__fmt__PCc_1, ...);
+void ___constructor__F_9sofstream__1(struct ofstream *__os__9sofstream_1);
+void ___constructor__F_9sofstreamPCcPCc__1(struct ofstream *__os__9sofstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
+void ___constructor__F_9sofstreamPCc__1(struct ofstream *__os__9sofstream_1, const char *__name__PCc_1);
+extern struct ofstream *__sout__9sofstream_1;
+extern struct ofstream *__serr__9sofstream_1;
 struct ifstream {
     void *__file__Pv_1;
 };
 static inline void ___constructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1);
 static inline void ___constructor__F_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1);
 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) /* ?{} */);
+}
 static inline void ___constructor__F_R9sifstream9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1, struct ifstream ___src__9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1) /* ?{} */);
+}
 static inline void ___destructor__F_R9sifstream_autogen___1(struct ifstream *___dst__R9sifstream_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_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_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1);
+static inline void ___constructor__F_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___destructor__F_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1);
+static inline struct ifstream ___operator_assign__F9sifstream_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_1);
+static inline void ___constructor__F_9sifstreamPv_autogen___1(struct ifstream *___dst__9sifstream_1, void *__file__Pv_1);
+static inline void ___constructor__F_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1) /* ?{} */);
+}
+static inline void ___constructor__F_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1) /* ?{} */);
+}
+static inline void ___destructor__F_9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1) /* ^?{} */);
+}
+static inline struct ifstream ___operator_assign__F9sifstream_9sifstream9sifstream_autogen___1(struct ifstream *___dst__9sifstream_1, struct ifstream ___src__9sifstream_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), (*___dst__R9sifstream_1)));
+    ((void)((*___dst__9sifstream_1).__file__Pv_1=___src__9sifstream_1.__file__Pv_1));
+    ((void)___constructor__F_9sifstream9sifstream_autogen___1((&___ret__9sifstream_1), (*___dst__9sifstream_1)));
     return ___ret__9sifstream_1;
+}
 static inline void ___constructor__F_R9sifstreamPv_autogen___1(struct ifstream *___dst__R9sifstream_1, void *__file__Pv_1){
     ((void)((*___dst__R9sifstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+}
 signed int __fail__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 signed int __eof__Fi_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 void __open__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
 void __open__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
 void __close__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 struct ifstream *__read__FR9sifstream_R9sifstreamPcUl__1(struct ifstream *__is__R9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
 struct ifstream *__ungetc__FR9sifstream_R9sifstreamc__1(struct ifstream *__is__R9sifstream_1, char __c__c_1);
 signed int __fmt__Fi_R9sifstreamPCc__1(struct ifstream *__anonymous_object1348, const char *__fmt__PCc_1, ...);
 void ___constructor__F_R9sifstream__1(struct ifstream *__is__R9sifstream_1);
 void ___constructor__F_R9sifstreamPCcPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
 void ___constructor__F_R9sifstreamPCc__1(struct ifstream *__is__R9sifstream_1, const char *__name__PCc_1);
 extern struct ifstream *__sin__R9sifstream_1;
+static inline void ___constructor__F_9sifstreamPv_autogen___1(struct ifstream *___dst__9sifstream_1, void *__file__Pv_1){
+    ((void)((*___dst__9sifstream_1).__file__Pv_1=__file__Pv_1) /* ?{} */);
+}
+signed int __fail__Fi_9sifstream__1(struct ifstream *__is__9sifstream_1);
+signed int __eof__Fi_9sifstream__1(struct ifstream *__is__9sifstream_1);
+void __open__F_9sifstreamPCcPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
+void __open__F_9sifstreamPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1);
+void __close__F_9sifstream__1(struct ifstream *__is__9sifstream_1);
+struct ifstream *__read__F9sifstream_9sifstreamPcUl__1(struct ifstream *__is__9sifstream_1, char *__data__Pc_1, unsigned long int __size__Ul_1);
+struct ifstream *__ungetc__F9sifstream_9sifstreamc__1(struct ifstream *__is__9sifstream_1, char __c__c_1);
+signed int __fmt__Fi_9sifstreamPCc__1(struct ifstream *__anonymous_object1348, const char *__fmt__PCc_1, ...);
+void ___constructor__F_9sifstream__1(struct ifstream *__is__9sifstream_1);
+void ___constructor__F_9sifstreamPCcPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1, const char *__mode__PCc_1);
+void ___constructor__F_9sifstreamPCc__1(struct ifstream *__is__9sifstream_1, const char *__name__PCc_1);
+extern struct ifstream *__sin__9sifstream_1;
 void __f__F_c__1(char __v__c_1){
     struct ofstream *_tmp_cp_ret2;
 …
     struct ofstream *_tmp_cp_ret4;
     __attribute__ ((unused)) struct ofstream *_thunk0(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1349))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1350))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1351, _Bool __anonymous_object1352))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1353))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1354, const char *__anonymous_object1355))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1356))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1357, _Bool __anonymous_object1358))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1359))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1360))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1363))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1364, const char *__anonymous_object1365))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1366))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1367, const char *__anonymous_object1368))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1369))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1370))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1371, const char *__anonymous_object1372, unsigned long int __anonymous_object1373))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1374, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1375))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1376))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1377, _Bool __anonymous_object1378))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1379))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1380, const char *__anonymous_object1381))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1382))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1383, _Bool __anonymous_object1384))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1385))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1386))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1389))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1390, const char *__anonymous_object1391))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1392))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1393, const char *__anonymous_object1394))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1395))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1396))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1397, const char *__anonymous_object1398, unsigned long int __anonymous_object1399))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1400, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0c__1(((_Bool (*)(void *__anonymous_object1401))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1402))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1403, _Bool __anonymous_object1404))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1405))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1406, const char *__anonymous_object1407))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1408))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1409, _Bool __anonymous_object1410))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1411))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1412))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1415))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1416, const char *__anonymous_object1417))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1418))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1419, const char *__anonymous_object1420))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1421))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1422))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1423, const char *__anonymous_object1424, unsigned long int __anonymous_object1425))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1426, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "char "))) , _tmp_cp_ret2)), __v__c_1))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1453))(&_thunk0))))) , _tmp_cp_ret4));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1349))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1350))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1351, _Bool __anonymous_object1352))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1353))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1354, const char *__anonymous_object1355))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1356))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1357, _Bool __anonymous_object1358))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1359))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1360))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1361))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1362))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1363))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1364, const char *__anonymous_object1365))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1366))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1367, const char *__anonymous_object1368))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1369))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1370))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1371, const char *__anonymous_object1372, unsigned long int __anonymous_object1373))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1374, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret4=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1375))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1376))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1377, _Bool __anonymous_object1378))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1379))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1380, const char *__anonymous_object1381))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1382))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1383, _Bool __anonymous_object1384))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1385))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1386))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1387))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1388))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1389))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1390, const char *__anonymous_object1391))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1392))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1393, const char *__anonymous_object1394))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1395))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1396))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1397, const char *__anonymous_object1398, unsigned long int __anonymous_object1399))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1400, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret3=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0c__1(((_Bool (*)(void *__anonymous_object1401))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1402))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1403, _Bool __anonymous_object1404))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1405))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1406, const char *__anonymous_object1407))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1408))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1409, _Bool __anonymous_object1410))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1411))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1412))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1413))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1414))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1415))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1416, const char *__anonymous_object1417))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1418))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1419, const char *__anonymous_object1420))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1421))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1422))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1423, const char *__anonymous_object1424, unsigned long int __anonymous_object1425))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1426, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret2=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1427))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1428))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1429, _Bool __anonymous_object1430))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1431))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1432, const char *__anonymous_object1433))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1434))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1435, _Bool __anonymous_object1436))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1437))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1438))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1439))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1440))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1441))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1442, const char *__anonymous_object1443))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1444))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1445, const char *__anonymous_object1446))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1447))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1448))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1449, const char *__anonymous_object1450, unsigned long int __anonymous_object1451))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1452, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "char "))) , _tmp_cp_ret2)), __v__c_1))) , _tmp_cp_ret3)), ((void *(*)(void *__anonymous_object1453))(&_thunk0))))) , _tmp_cp_ret4));
+}
 void __f__F_Sc__1(signed char __v__Sc_1){
 …
     struct ofstream *_tmp_cp_ret7;
     __attribute__ ((unused)) struct ofstream *_thunk1(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1454))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1455))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1456, _Bool __anonymous_object1457))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1458))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1459, const char *__anonymous_object1460))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1461))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1462, _Bool __anonymous_object1463))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1464))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1465))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1468))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1469, const char *__anonymous_object1470))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1471))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1474))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1475))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1476, const char *__anonymous_object1477, unsigned long int __anonymous_object1478))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1479, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1480))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1481))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1482, _Bool __anonymous_object1483))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1484))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1485, const char *__anonymous_object1486))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1487))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1488, _Bool __anonymous_object1489))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1490))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1491))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1494))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1495, const char *__anonymous_object1496))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1497))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1498, const char *__anonymous_object1499))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1500))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1501))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1502, const char *__anonymous_object1503, unsigned long int __anonymous_object1504))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1505, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Sc__1(((_Bool (*)(void *__anonymous_object1506))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1507))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1508, _Bool __anonymous_object1509))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1510))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1511, const char *__anonymous_object1512))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1513))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1514, _Bool __anonymous_object1515))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1516))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1517))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1520))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1521, const char *__anonymous_object1522))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1523))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1524, const char *__anonymous_object1525))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1526))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1527))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1528, const char *__anonymous_object1529, unsigned long int __anonymous_object1530))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1531, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed char "))) , _tmp_cp_ret5)), __v__Sc_1))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1558))(&_thunk1))))) , _tmp_cp_ret7));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1454))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1455))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1456, _Bool __anonymous_object1457))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1458))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1459, const char *__anonymous_object1460))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1461))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1462, _Bool __anonymous_object1463))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1464))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1465))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1466))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1467))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1468))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1469, const char *__anonymous_object1470))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1471))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1472, const char *__anonymous_object1473))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1474))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1475))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1476, const char *__anonymous_object1477, unsigned long int __anonymous_object1478))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1479, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret7=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1480))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1481))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1482, _Bool __anonymous_object1483))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1484))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1485, const char *__anonymous_object1486))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1487))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1488, _Bool __anonymous_object1489))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1490))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1491))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1492))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1493))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1494))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1495, const char *__anonymous_object1496))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1497))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1498, const char *__anonymous_object1499))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1500))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1501))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1502, const char *__anonymous_object1503, unsigned long int __anonymous_object1504))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1505, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret6=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Sc__1(((_Bool (*)(void *__anonymous_object1506))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1507))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1508, _Bool __anonymous_object1509))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1510))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1511, const char *__anonymous_object1512))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1513))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1514, _Bool __anonymous_object1515))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1516))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1517))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1518))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1519))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1520))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1521, const char *__anonymous_object1522))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1523))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1524, const char *__anonymous_object1525))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1526))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1527))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1528, const char *__anonymous_object1529, unsigned long int __anonymous_object1530))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1531, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret5=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1532))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1533))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1534, _Bool __anonymous_object1535))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1536))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1537, const char *__anonymous_object1538))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1539))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1540, _Bool __anonymous_object1541))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1542))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1543))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1544))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1545))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1546))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1547, const char *__anonymous_object1548))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1549))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1550, const char *__anonymous_object1551))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1552))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1553))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1554, const char *__anonymous_object1555, unsigned long int __anonymous_object1556))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1557, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "signed char "))) , _tmp_cp_ret5)), __v__Sc_1))) , _tmp_cp_ret6)), ((void *(*)(void *__anonymous_object1558))(&_thunk1))))) , _tmp_cp_ret7));
+}
 void __f__F_Uc__1(unsigned char __v__Uc_1){
 …
     struct ofstream *_tmp_cp_ret10;
     __attribute__ ((unused)) struct ofstream *_thunk2(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1559))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1560))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1561, _Bool __anonymous_object1562))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1563))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1564, const char *__anonymous_object1565))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1566))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1567, _Bool __anonymous_object1568))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1569))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1570))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1573))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1574, const char *__anonymous_object1575))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1576))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1579))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1580))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1581, const char *__anonymous_object1582, unsigned long int __anonymous_object1583))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1584, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1585))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1586))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1587, _Bool __anonymous_object1588))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1589))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1590, const char *__anonymous_object1591))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1592))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1593, _Bool __anonymous_object1594))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1595))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1596))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1599))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1600, const char *__anonymous_object1601))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1602))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1603, const char *__anonymous_object1604))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1605))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1606))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1607, const char *__anonymous_object1608, unsigned long int __anonymous_object1609))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1610, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Uc__1(((_Bool (*)(void *__anonymous_object1611))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1612))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1613, _Bool __anonymous_object1614))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1615))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1616, const char *__anonymous_object1617))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1618))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1619, _Bool __anonymous_object1620))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1621))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1622))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1625))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1626, const char *__anonymous_object1627))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1628))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1629, const char *__anonymous_object1630))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1631))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1632))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1633, const char *__anonymous_object1634, unsigned long int __anonymous_object1635))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1636, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned char "))) , _tmp_cp_ret8)), __v__Uc_1))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1663))(&_thunk2))))) , _tmp_cp_ret10));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1559))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1560))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1561, _Bool __anonymous_object1562))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1563))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1564, const char *__anonymous_object1565))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1566))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1567, _Bool __anonymous_object1568))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1569))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1570))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1571))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1572))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1573))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1574, const char *__anonymous_object1575))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1576))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1577, const char *__anonymous_object1578))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1579))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1580))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1581, const char *__anonymous_object1582, unsigned long int __anonymous_object1583))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1584, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret10=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1585))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1586))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1587, _Bool __anonymous_object1588))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1589))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1590, const char *__anonymous_object1591))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1592))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1593, _Bool __anonymous_object1594))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1595))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1596))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1597))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1598))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1599))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1600, const char *__anonymous_object1601))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1602))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1603, const char *__anonymous_object1604))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1605))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1606))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1607, const char *__anonymous_object1608, unsigned long int __anonymous_object1609))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1610, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret9=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Uc__1(((_Bool (*)(void *__anonymous_object1611))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1612))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1613, _Bool __anonymous_object1614))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1615))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1616, const char *__anonymous_object1617))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1618))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1619, _Bool __anonymous_object1620))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1621))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1622))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1623))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1624))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1625))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1626, const char *__anonymous_object1627))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1628))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1629, const char *__anonymous_object1630))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1631))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1632))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1633, const char *__anonymous_object1634, unsigned long int __anonymous_object1635))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1636, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret8=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1637))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1638))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1639, _Bool __anonymous_object1640))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1641))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1642, const char *__anonymous_object1643))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1644))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1645, _Bool __anonymous_object1646))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1647))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1648))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1649))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1650))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1651))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1652, const char *__anonymous_object1653))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1654))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1655, const char *__anonymous_object1656))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1657))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1658))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1659, const char *__anonymous_object1660, unsigned long int __anonymous_object1661))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1662, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "unsigned char "))) , _tmp_cp_ret8)), __v__Uc_1))) , _tmp_cp_ret9)), ((void *(*)(void *__anonymous_object1663))(&_thunk2))))) , _tmp_cp_ret10));
+}
 void __f__F_s__1(signed short int __v__s_1){
 …
     struct ofstream *_tmp_cp_ret13;
     __attribute__ ((unused)) struct ofstream *_thunk3(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1664))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1665))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1666, _Bool __anonymous_object1667))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1668))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1669, const char *__anonymous_object1670))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1671))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1672, _Bool __anonymous_object1673))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1674))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1675))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1678))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1679, const char *__anonymous_object1680))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1681))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1684))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1685))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1686, const char *__anonymous_object1687, unsigned long int __anonymous_object1688))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1689, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1690))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1691))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1692, _Bool __anonymous_object1693))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1694))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1695, const char *__anonymous_object1696))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1697))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1698, _Bool __anonymous_object1699))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1700))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1701))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1704))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1705, const char *__anonymous_object1706))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1707))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1708, const char *__anonymous_object1709))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1710))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1711))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1712, const char *__anonymous_object1713, unsigned long int __anonymous_object1714))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1715, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0s__1(((_Bool (*)(void *__anonymous_object1716))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1717))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1718, _Bool __anonymous_object1719))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1720))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1721, const char *__anonymous_object1722))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1723))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1724, _Bool __anonymous_object1725))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1726))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1727))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1730))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1731, const char *__anonymous_object1732))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1733))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1734, const char *__anonymous_object1735))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1736))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1737))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1738, const char *__anonymous_object1739, unsigned long int __anonymous_object1740))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1741, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "signed short int"))) , _tmp_cp_ret11)), __v__s_1))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1768))(&_thunk3))))) , _tmp_cp_ret13));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1664))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1665))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1666, _Bool __anonymous_object1667))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1668))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1669, const char *__anonymous_object1670))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1671))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1672, _Bool __anonymous_object1673))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1674))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1675))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1676))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1677))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1678))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1679, const char *__anonymous_object1680))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1681))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1682, const char *__anonymous_object1683))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1684))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1685))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1686, const char *__anonymous_object1687, unsigned long int __anonymous_object1688))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1689, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret13=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1690))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1691))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1692, _Bool __anonymous_object1693))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1694))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1695, const char *__anonymous_object1696))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1697))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1698, _Bool __anonymous_object1699))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1700))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1701))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1702))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1703))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1704))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1705, const char *__anonymous_object1706))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1707))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1708, const char *__anonymous_object1709))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1710))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1711))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1712, const char *__anonymous_object1713, unsigned long int __anonymous_object1714))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1715, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret12=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0s__1(((_Bool (*)(void *__anonymous_object1716))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1717))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1718, _Bool __anonymous_object1719))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1720))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1721, const char *__anonymous_object1722))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1723))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1724, _Bool __anonymous_object1725))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1726))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1727))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1728))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1729))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1730))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1731, const char *__anonymous_object1732))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1733))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1734, const char *__anonymous_object1735))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1736))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1737))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1738, const char *__anonymous_object1739, unsigned long int __anonymous_object1740))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1741, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret11=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1742))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1743))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1744, _Bool __anonymous_object1745))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1746))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1747, const char *__anonymous_object1748))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1749))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1750, _Bool __anonymous_object1751))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1752))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1753))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1754))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1755))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1756))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1757, const char *__anonymous_object1758))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1759))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1760, const char *__anonymous_object1761))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1762))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1763))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1764, const char *__anonymous_object1765, unsigned long int __anonymous_object1766))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1767, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "signed short int"))) , _tmp_cp_ret11)), __v__s_1))) , _tmp_cp_ret12)), ((void *(*)(void *__anonymous_object1768))(&_thunk3))))) , _tmp_cp_ret13));
+}
 void __f__F_Us__1(unsigned short int __v__Us_1){
 …
     struct ofstream *_tmp_cp_ret16;
     __attribute__ ((unused)) struct ofstream *_thunk4(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1769))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1770))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1771, _Bool __anonymous_object1772))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1773))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1774, const char *__anonymous_object1775))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1776))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1777, _Bool __anonymous_object1778))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1779))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1780))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1783))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1784, const char *__anonymous_object1785))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1786))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1789))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1790))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1791, const char *__anonymous_object1792, unsigned long int __anonymous_object1793))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1794, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1795))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1796))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1797, _Bool __anonymous_object1798))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1799))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1800, const char *__anonymous_object1801))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1802))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1803, _Bool __anonymous_object1804))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1805))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1806))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1809))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1810, const char *__anonymous_object1811))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1812))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1813, const char *__anonymous_object1814))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1815))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1816))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1817, const char *__anonymous_object1818, unsigned long int __anonymous_object1819))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1820, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Us__1(((_Bool (*)(void *__anonymous_object1821))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1822))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1823, _Bool __anonymous_object1824))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1825))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1826, const char *__anonymous_object1827))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1828))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1829, _Bool __anonymous_object1830))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1831))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1832))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1835))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1836, const char *__anonymous_object1837))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1838))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1839, const char *__anonymous_object1840))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1841))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1842))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1843, const char *__anonymous_object1844, unsigned long int __anonymous_object1845))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1846, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "unsigned short int"))) , _tmp_cp_ret14)), __v__Us_1))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1873))(&_thunk4))))) , _tmp_cp_ret16));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1769))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1770))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1771, _Bool __anonymous_object1772))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1773))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1774, const char *__anonymous_object1775))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1776))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1777, _Bool __anonymous_object1778))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1779))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1780))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1781))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1782))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1783))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1784, const char *__anonymous_object1785))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1786))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1787, const char *__anonymous_object1788))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1789))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1790))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1791, const char *__anonymous_object1792, unsigned long int __anonymous_object1793))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1794, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret16=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1795))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1796))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1797, _Bool __anonymous_object1798))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1799))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1800, const char *__anonymous_object1801))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1802))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1803, _Bool __anonymous_object1804))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1805))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1806))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1807))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1808))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1809))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1810, const char *__anonymous_object1811))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1812))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1813, const char *__anonymous_object1814))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1815))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1816))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1817, const char *__anonymous_object1818, unsigned long int __anonymous_object1819))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1820, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret15=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Us__1(((_Bool (*)(void *__anonymous_object1821))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1822))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1823, _Bool __anonymous_object1824))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1825))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1826, const char *__anonymous_object1827))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1828))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1829, _Bool __anonymous_object1830))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1831))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1832))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1833))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1834))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1835))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1836, const char *__anonymous_object1837))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1838))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1839, const char *__anonymous_object1840))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1841))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1842))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1843, const char *__anonymous_object1844, unsigned long int __anonymous_object1845))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1846, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret14=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1847))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1848))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1849, _Bool __anonymous_object1850))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1851))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1852, const char *__anonymous_object1853))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1854))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1855, _Bool __anonymous_object1856))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1857))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1858))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1859))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1860))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1861))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1862, const char *__anonymous_object1863))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1864))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1865, const char *__anonymous_object1866))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1867))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1868))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1869, const char *__anonymous_object1870, unsigned long int __anonymous_object1871))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1872, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "unsigned short int"))) , _tmp_cp_ret14)), __v__Us_1))) , _tmp_cp_ret15)), ((void *(*)(void *__anonymous_object1873))(&_thunk4))))) , _tmp_cp_ret16));
+}
 void __f__F_Ui__1(unsigned int __v__Ui_1){
 …
     struct ofstream *_tmp_cp_ret19;
     __attribute__ ((unused)) struct ofstream *_thunk5(struct ofstream *_p0){
         return __endl__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0__1(((_Bool (*)(void *__anonymous_object1874))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1875))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1876, _Bool __anonymous_object1877))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1878))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1879, const char *__anonymous_object1880))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1881))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1882, _Bool __anonymous_object1883))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1884))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1885))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1888))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1889, const char *__anonymous_object1890))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1891))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1894))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1895))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1896, const char *__anonymous_object1897, unsigned long int __anonymous_object1898))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1899, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)_p0));
+    }
     ((void)(((void)(_tmp_cp_ret19=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PFRd0_Rd0___1(((_Bool (*)(void *__anonymous_object1900))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1901))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1902, _Bool __anonymous_object1903))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1904))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1905, const char *__anonymous_object1906))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1907))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1908, _Bool __anonymous_object1909))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1910))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1911))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1914))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1915, const char *__anonymous_object1916))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1917))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1918, const char *__anonymous_object1919))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1920))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1921))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1922, const char *__anonymous_object1923, unsigned long int __anonymous_object1924))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1925, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0Ui__1(((_Bool (*)(void *__anonymous_object1926))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1927))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1928, _Bool __anonymous_object1929))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1930))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1931, const char *__anonymous_object1932))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1933))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1934, _Bool __anonymous_object1935))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1936))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1937))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1940))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1941, const char *__anonymous_object1942))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1943))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1944, const char *__anonymous_object1945))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1946))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1947))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1948, const char *__anonymous_object1949, unsigned long int __anonymous_object1950))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1951, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__PFb_Rd0___sepReset__PF_Rd0___sepReset__PF_Rd0b___sepGetCur__PFPCc_Rd0___sepSetCur__PF_Rd0PCc___getNL__PFb_Rd0___setNL__PF_Rd0b___sepOn__PF_Rd0___sepOff__PF_Rd0___sepDisable__PFb_Rd0___sepEnable__PFb_Rd0___sepGet__PFPCc_Rd0___sepSet__PF_Rd0PCc___sepGetTuple__PFPCc_Rd0___sepSetTuple__PF_Rd0PCc___fail__PFi_Rd0___flush__PFi_Rd0___open__PF_Rd0PCcPCc___close__PF_Rd0___write__PFRd0_Rd0PCcUl___fmt__PFi_Rd0PCc__FRd0_Rd0PCc__1(((_Bool (*)(void *__anonymous_object1952))__sepPrt__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1953))__sepReset__F_R9sofstream__1), ((void (*)(void *__anonymous_object1954, _Bool __anonymous_object1955))__sepReset__F_R9sofstreamb__1), ((const char *(*)(void *__anonymous_object1956))__sepGetCur__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1957, const char *__anonymous_object1958))__sepSetCur__F_R9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1959))__getNL__Fb_R9sofstream__1), ((void (*)(void *__anonymous_object1960, _Bool __anonymous_object1961))__setNL__F_R9sofstreamb__1), ((void (*)(void *__anonymous_object1962))__sepOn__F_R9sofstream__1), ((void (*)(void *__anonymous_object1963))__sepOff__F_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1964))__sepDisable__Fb_R9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepEnable__Fb_R9sofstream__1), ((const char *(*)(void *__anonymous_object1966))__sepGet__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1967, const char *__anonymous_object1968))__sepSet__F_R9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1969))__sepGetTuple__FPCc_R9sofstream__1), ((void (*)(void *__anonymous_object1970, const char *__anonymous_object1971))__sepSetTuple__F_R9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1972))__fail__Fi_R9sofstream__1), ((signed int (*)(void *__anonymous_object1973))__flush__Fi_R9sofstream__1), ((void (*)(void *__os__R7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_R9sofstreamPCcPCc__1), ((void (*)(void *__os__R7tostype_1))__close__F_R9sofstream__1), ((void *(*)(void *__anonymous_object1974, const char *__anonymous_object1975, unsigned long int __anonymous_object1976))__write__FR9sofstream_R9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1977, const char *__fmt__PCc_1, ...))__fmt__Fi_R9sofstreamPCc__1), ((void *)__sout__R9sofstream_1), "size_t"))) , _tmp_cp_ret17)), __v__Ui_1))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object1978))(&_thunk5))))) , _tmp_cp_ret19));
+        return __endl__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0__1(((_Bool (*)(void *__anonymous_object1874))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1875))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1876, _Bool __anonymous_object1877))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1878))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1879, const char *__anonymous_object1880))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1881))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1882, _Bool __anonymous_object1883))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1884))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1885))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1886))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1887))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1888))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1889, const char *__anonymous_object1890))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1891))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1892, const char *__anonymous_object1893))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1894))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1895))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1896, const char *__anonymous_object1897, unsigned long int __anonymous_object1898))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1899, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)_p0));
+    }
+    ((void)(((void)(_tmp_cp_ret19=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Fd0_d0___1(((_Bool (*)(void *__anonymous_object1900))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1901))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1902, _Bool __anonymous_object1903))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1904))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1905, const char *__anonymous_object1906))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1907))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1908, _Bool __anonymous_object1909))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1910))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1911))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1912))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1913))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1914))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1915, const char *__anonymous_object1916))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1917))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1918, const char *__anonymous_object1919))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1920))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1921))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1922, const char *__anonymous_object1923, unsigned long int __anonymous_object1924))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1925, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret18=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0Ui__1(((_Bool (*)(void *__anonymous_object1926))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1927))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1928, _Bool __anonymous_object1929))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1930))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1931, const char *__anonymous_object1932))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1933))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1934, _Bool __anonymous_object1935))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1936))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1937))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1938))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1939))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1940))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1941, const char *__anonymous_object1942))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1943))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1944, const char *__anonymous_object1945))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1946))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1947))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1948, const char *__anonymous_object1949, unsigned long int __anonymous_object1950))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1951, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)(((void)(_tmp_cp_ret17=___operator_bitor__A0_1_0_0___sepPrt__Fb_d0___sepReset__F_d0___sepReset__F_d0b___sepGetCur__FPCc_d0___sepSetCur__F_d0PCc___getNL__Fb_d0___setNL__F_d0b___sepOn__F_d0___sepOff__F_d0___sepDisable__Fb_d0___sepEnable__Fb_d0___sepGet__FPCc_d0___sepSet__F_d0PCc___sepGetTuple__FPCc_d0___sepSetTuple__F_d0PCc___fail__Fi_d0___flush__Fi_d0___open__F_d0PCcPCc___close__F_d0___write__Fd0_d0PCcUl___fmt__Fi_d0PCc__Fd0_d0PCc__1(((_Bool (*)(void *__anonymous_object1952))__sepPrt__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1953))__sepReset__F_9sofstream__1), ((void (*)(void *__anonymous_object1954, _Bool __anonymous_object1955))__sepReset__F_9sofstreamb__1), ((const char *(*)(void *__anonymous_object1956))__sepGetCur__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1957, const char *__anonymous_object1958))__sepSetCur__F_9sofstreamPCc__1), ((_Bool (*)(void *__anonymous_object1959))__getNL__Fb_9sofstream__1), ((void (*)(void *__anonymous_object1960, _Bool __anonymous_object1961))__setNL__F_9sofstreamb__1), ((void (*)(void *__anonymous_object1962))__sepOn__F_9sofstream__1), ((void (*)(void *__anonymous_object1963))__sepOff__F_9sofstream__1), ((_Bool (*)(void *__anonymous_object1964))__sepDisable__Fb_9sofstream__1), ((_Bool (*)(void *__anonymous_object1965))__sepEnable__Fb_9sofstream__1), ((const char *(*)(void *__anonymous_object1966))__sepGet__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1967, const char *__anonymous_object1968))__sepSet__F_9sofstreamPCc__1), ((const char *(*)(void *__anonymous_object1969))__sepGetTuple__FPCc_9sofstream__1), ((void (*)(void *__anonymous_object1970, const char *__anonymous_object1971))__sepSetTuple__F_9sofstreamPCc__1), ((signed int (*)(void *__anonymous_object1972))__fail__Fi_9sofstream__1), ((signed int (*)(void *__anonymous_object1973))__flush__Fi_9sofstream__1), ((void (*)(void *__os__7tostype_1, const char *__name__PCc_1, const char *__mode__PCc_1))__open__F_9sofstreamPCcPCc__1), ((void (*)(void *__os__7tostype_1))__close__F_9sofstream__1), ((void *(*)(void *__anonymous_object1974, const char *__anonymous_object1975, unsigned long int __anonymous_object1976))__write__F9sofstream_9sofstreamPCcUl__1), ((signed int (*)(void *__anonymous_object1977, const char *__fmt__PCc_1, ...))__fmt__Fi_9sofstreamPCc__1), ((void *)__sout__9sofstream_1), "size_t"))) , _tmp_cp_ret17)), __v__Ui_1))) , _tmp_cp_ret18)), ((void *(*)(void *__anonymous_object1978))(&_thunk5))))) , _tmp_cp_ret19));
+}
 signed int __main__Fi___1(){

src/tests/.expect/math1.x64.txt

-              r3ef35bd
+              reba74ba
 \ 16 256
 \ 912673 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
-log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
-log2:3 3 3
-log10:2 2 2
-log1p:0.693147 0.693147180559945 0.693147180559945309
-ilogb:0 0 0
-logb:3 3 3
-sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
-cbrt:3 3 3
-hypot:1.41421 1.4142135623731 1.41421356237309505

src/tests/.expect/math1.x86.txt

-              r3ef35bd
+              reba74ba
 \ 16 256
 \ 912673 256 64 -64 0.015625 -0.015625 18.3791736799526 0.264715-1.1922i
-log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
-log2:3 3 3
-log10:2 2 2
-log1p:0.693147 0.693147180559945 0.693147180559945309
-ilogb:0 0 0
-logb:3 3 3
-sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
-cbrt:3 3 3
-hypot:1.41421 1.4142135623731 1.41421356237309505

src/tests/.expect/math2.x64.txt

-              r3ef35bd
+              reba74ba
+log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2:3 3 3
+log10:2 2 2
+log1p:0.693147 0.693147180559945 0.693147180559945309
+ilogb:0 0 0
+logb:3 3 3
+sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+cbrt:3 3 3
+hypot:1.41421 1.4142135623731 1.41421356237309505
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i
 …
 atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
 atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831
-sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
-cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
-tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
-acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
-asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
-atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
-erf:0.842701 0.842700792949715 0.842700792949714869
-erfc:0.157299 0.157299207050285 0.157299207050285131
-lgamma:1.79176 1.79175946922805 1.791759469228055
-lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
-tgamma:6 6 6

src/tests/.expect/math2.x86.txt

-              r3ef35bd
+              reba74ba
+log:0 0 0 0.346574+0.785398i 0.346573590279973+0.785398163397448i 0.346573590279972655+0.78539816339744831i
+log2:3 3 3
+log10:2 2 2
+log1p:0.693147 0.693147180559945 0.693147180559945309
+ilogb:0 0 0
+logb:3 3 3
+sqrt:1 1 1 1.09868+0.45509i 1.09868411346781+0.455089860562227i 1.09868411346780997+0.455089860562227341i
+cbrt:3 3 3
+hypot:1.41421 1.4142135623731 1.41421356237309505
 sin:0.841471 0.841470984807897 0.841470984807896507 1.29846+0.634964i 1.29845758141598+0.634963914784736i 1.29845758141597729+0.634963914784736108i
 cos:0.540302 0.54030230586814 0.540302305868139717 0.83373-0.988898i 0.833730025131149-0.988897705762865i 0.833730025131149049-0.988897705762865096i
 …
 atan:0.785398 0.785398163397448 0.78539816339744831 1.01722+0.402359i 1.01722196789785+0.402359478108525i 1.01722196789785137+0.402359478108525094i
 atan2:0.785398 0.785398163397448 0.78539816339744831 atan:0.785398 0.785398163397448 0.78539816339744831
-sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
-cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
-tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
-acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
-asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
-atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
-erf:0.842701 0.842700792949715 0.842700792949714869
-erfc:0.157299 0.157299207050285 0.157299207050285131
-lgamma:1.79176 1.79175946922805 1.791759469228055
-lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
-tgamma:6 6 6

src/tests/.expect/math3.x64.txt

-              r3ef35bd
+              reba74ba
+floor:1 1 1
+ceil:2 2 2
+trunc:3 3 3
+rint:2 2 2
+rint:2 2 2
+rint:2 2 2
+lrint:2 2 2
+llrint:2 2 2
+nearbyint:4 4 4
+round:2 2 2
+round:2 2 2
+round:2 2 2
+lround:2 2 2
+llround:2 2 2
+copysign:-1 -1 -1
+frexp:0.5 3 0.5 3 0.5 3
+ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
+nexttoward:2 2 2
+scalbn:16 16 16
+scalbln:16 16 16
+sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
+cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
+tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
+acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
+atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
+erf:0.842701 0.842700792949715 0.842700792949714869
+erfc:0.157299 0.157299207050285 0.157299207050285131
+lgamma:1.79176 1.79175946922805 1.791759469228055
+lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
+tgamma:6 6 6

src/tests/.expect/math3.x86.txt

-              r3ef35bd
+              reba74ba
+floor:1 1 1
+ceil:2 2 2
+trunc:3 3 3
+rint:2 2 2
+rint:2 2 2
+rint:2 2 2
+lrint:2 2 2
+llrint:2 2 2
+nearbyint:4 4 4
+round:2 2 2
+round:2 2 2
+round:2 2 2
+lround:2 2 2
+llround:2 2 2
+copysign:-1 -1 -1
+frexp:0.5 3 0.5 3 0.5 3
+ldexp:8 8 8
+modf:2 0.3 2 0.3 2 0.3
+modf:2, 0.3 2, 0.3 2, 0.3
+nextafter:2 2 2
+nexttoward:2 2 2
+scalbn:16 16 16
+scalbln:16 16 16
+sinh:1.1752 1.1752011936438 1.17520119364380146 0.634964+1.29846i 0.634963914784736+1.29845758141598i 0.634963914784736108+1.29845758141597729i
+cosh:1.54308 1.54308063481524 1.54308063481524378 0.83373+0.988898i 0.833730025131149+0.988897705762865i 0.833730025131149049+0.988897705762865096i
+tanh:0.761594 0.761594155955765 0.761594155955764888 1.08392+0.271753i 1.08392332733869+0.271752585319512i 1.08392332733869454+0.271752585319511717i
+acosh:0 0 0 1.06128+0.904557i 1.06127506190504+0.904556894302381i 1.06127506190503565+0.904556894302381364i
+asinh:0.881374 0.881373587019543 0.881373587019543025 1.06128+0.666239i 1.06127506190504+0.666239432492515i 1.06127506190503565+0.666239432492515255i
+atanh:inf inf inf 0.402359+1.01722i 0.402359478108525+1.01722196789785i 0.402359478108525094+1.01722196789785137i
+erf:0.842701 0.842700792949715 0.842700792949714869
+erfc:0.157299 0.157299207050285 0.157299207050285131
+lgamma:1.79176 1.79175946922805 1.791759469228055
+lgamma:1.79176 1 1.79175946922805 1 1.791759469228055 1
+tgamma:6 6 6

src/tests/Makefile.am

r3ef35bd	reba74ba
129	129	warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@
130	130	${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
	131
	132	#builtins
	133	builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@
	134	${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only

src/tests/Makefile.in

-              r3ef35bd
+              reba74ba
         ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
+#builtins
+builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
 # 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/tests/concurrent/coroutineYield.c

-              r3ef35bd
+              reba74ba
 #include <stdlib>
 #include <thread>
+#include <time>
+#ifndef PREEMPTION_RATE
+#define PREEMPTION_RATE 10`ms
+#endif
+Duration default_preemption() {
+        return PREEMPTION_RATE;
+}
 #ifdef LONG_TEST

src/tests/concurrent/examples/matrixSum.c

-              r3ef35bd
+              reba74ba
 // Created On       : Mon Oct  9 08:29:28 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Dec  5 22:56:46 2017
 // Update Count     : 4
+// Last Modified On : Fri May 25 09:34:27 2018
+// Update Count     : 10
 //
 …
 thread Adder {
     int * row, cols, * subtotal;                                                // communication
+        int * row, cols, & subtotal;                                            // communication
 };
 void ?{}( Adder & adder, int row[], int cols, int & subtotal ) {
+    adder.row = row;
+    adder.cols = cols;
+    adder.subtotal = &subtotal;
+        adder.[ row, cols ] = [ row, cols ];                            // expression disallowed in multi-member access
+        &adder.subtotal = &subtotal;
+}
 void main( Adder & adder ) with( adder ) {
     *subtotal = 0;
     for ( int c = 0; c < cols; c += 1 ) {
                 *subtotal += row[c];
     } // for
+void main( Adder & adder ) with( adder ) {                              // thread starts here
+        subtotal = 0;
+        for ( int c = 0; c < cols; c += 1 ) {
+                subtotal += row[c];
+        } // for
+}
 int main() {
     const int rows = 10, cols = 1000;
     int matrix[rows][cols], subtotals[rows], total = 0;
     processor p;                                                                                // extra kernel thread
+        const int rows = 10, cols = 1000;
+        int matrix[rows][cols], subtotals[rows], total = 0;
+        processor p;                                                                            // add kernel thread
     for ( int r = 0; r < rows; r += 1 ) {
+        for ( int r = 0; r < rows; r += 1 ) {
                 for ( int c = 0; c < cols; c += 1 ) {
                         matrix[r][c] = 1;
                 } // for
     } // for
     Adder * adders[rows];
     for ( int r = 0; r < rows; r += 1 ) {                               // start threads to sum rows
+        } // for
+        Adder * adders[rows];
+        for ( int r = 0; r < rows; r += 1 ) {                           // start threads to sum rows
                 adders[r] = &(*malloc()){ matrix[r], cols, subtotals[r] };
 //              adders[r] = new( matrix[r], cols, &subtotals[r] );
     } // for
     for ( int r = 0; r < rows; r += 1 ) {                               // wait for threads to finish
+        } // for
+        for ( int r = 0; r < rows; r += 1 ) {                           // wait for threads to finish
                 delete( adders[r] );
                 total += subtotals[r];                                                  // total subtotals
     } // for
     sout | total | endl;
+        } // for
+        sout | total | endl;
+}

src/tests/concurrent/signal/block.c

-              r3ef35bd
+              reba74ba
 #include <time>
-#ifdef LONG_TEST
-static const unsigned long N = 150_000ul;
-#else
-static const unsigned long N = 5_000ul;
-#endif
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
 …
         return PREEMPTION_RATE;
+}
+#ifdef LONG_TEST
+static const unsigned long N = 150_000ul;
+#else
+static const unsigned long N = 5_000ul;
+#endif
 enum state_t { WAITED, SIGNAL, BARGE };

src/tests/concurrent/signal/disjoint.c

-              r3ef35bd
+              reba74ba
 #include <thread>
 #include <time>
-#ifdef LONG_TEST
-static const unsigned long N = 300_000ul;
-#else
-static const unsigned long N = 10_000ul;
-#endif
 #ifndef PREEMPTION_RATE
 …
         return PREEMPTION_RATE;
+}
+#ifdef LONG_TEST
+static const unsigned long N = 300_000ul;
+#else
+static const unsigned long N = 10_000ul;
+#endif
 enum state_t { WAIT, SIGNAL, BARGE };

src/tests/concurrent/signal/wait.c

-              r3ef35bd
+              reba74ba
 #include <time>
-#ifdef LONG_TEST
-static const unsigned long N = 375_000ul;
-#else
-static const unsigned long N = 2_500ul;
-#endif
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
 …
         return PREEMPTION_RATE;
+}
+#ifdef LONG_TEST
+static const unsigned long N = 375_000ul;
+#else
+static const unsigned long N = 2_500ul;
+#endif
 monitor global_t {};

src/tests/functions.c

-              r3ef35bd
+              reba74ba
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // functions.c --
 //
+//
+// functions.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Wed Aug 17 08:39:58 2016
 …
 // Last Modified On : Wed Jan 17 22:44:12 2018
 // Update Count     : 12
 //
+//
 // ANSI function definitions
 …
 static const int * f1() {}
 static [ const int ] f2() {}
+static [ * const int ] f2() {}
 static inline [ const * int ] f3() {}
 static inline [ const [ * int, int ] ] f4() {}

src/tests/io2.c

-              r3ef35bd
+              reba74ba
 // file "LICENCE" distributed with Cforall.
 //
 // io.c --
+// io2.c --
 //
 // Author           : Peter A. Buhr
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jan 26 15:19:34 2018
 // Update Count     : 100
+// Last Modified On : Thu May 24 21:17:41 2018
+// Update Count     : 103
 //
 …
         enum { size = 10 };
         char s1[size], s2[size];
-        int x = 3, y = 5, z = 7;
-        sout | x * 3 | y + 1 | z << 2 | x == y | (x | y) | (x || y) | (x > z ? 1 : 2) | endl;
-        sout | 1 | 2 | 3 | endl;
-        sout | '1' | '2' | '3' | endl;
-        sout | 1 | "" | 2 | "" | 3 | endl;
-        sout | endl;
-        sout | "opening delimiters" | endl;
-        sout
-                 | "x (" | 1
-                 | "x [" | 2
-                 | "x {" | 3
-                 | "x =" | 4
-                 | "x $" | 5
-                 | "x £" | 6
-                 | "x ¥" | 7
-                 | "x ¡" | 8
-                 | "x ¿" | 9
-                 | "x «" | 10
-                 | endl | endl;
-        sout | "closing delimiters" | endl;
-        sout
-                 | 1 | ", x"
-                 | 2 | ". x"
-                 | 3 | "; x"
-                 | 4 | "! x"
-                 | 5 | "? x"
-                 | 6 | "% x"
-                 | 7 | "¢ x"
-                 | 8 | "» x"
-                 | 9 | ") x"
-                 | 10 | "] x"
-                 | 11 | "} x"
-                 | endl | endl;
-        sout | "opening/closing delimiters" | endl;
-        sout
-                 | "x`" | 1 | "`x'" | 2
-                 | "'x\"" | 3 | "\"x:" | 4
-                 | ":x " | 5 | " x\t" | 6
-                 | "\tx\f" | 7 | "\fx\v" | 8
-                 | "\vx\n" | 9 | "\nx\r" | 10
-                 | "\rx"
-                 | endl | endl;
-        sout | "override opening/closing delimiters" | endl;
-        sout | "x ( " | 1 | " ) x" | 2 | " , x" | 3 | " :x: " | 4 | endl;
-        sout | endl;
         ifstream in = { "io.data" };                                            // create / open file
 …
 // Local Variables: //
 // tab-width: 4 //
 // compile-command: "cfa io.c" //
+// compile-command: "cfa io2.c" //
 // End: //

src/tests/math1.c

-              r3ef35bd
+              reba74ba
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Aug 11 15:16:41 2017
 // Update Count     : 84
+// Last Modified On : Thu May 24 21:01:15 2018
+// Update Count     : 85
 //
 …
     sout | "\\" | b | b \ e | endl;
     sout | "\\" | 'a' \ 3u | 2 \ 8u | 4 \ 3u | -4 \ 3u | 4 \ -3 | -4 \ -3 | 4.0 \ 2.1 | (1.0f+2.0fi) \ (3.0f+2.0fi) | endl;
-        //---------------------- Logarithm ----------------------
-        sout | "log:" | log( 1.0F ) | log( 1.0D ) | log( 1.0L ) | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0DL+1.0LI ) | endl;
-        sout | "log2:" | log2( 8.0F ) | log2( 8.0D ) | log2( 8.0L ) | endl;
-        sout | "log10:" | log10( 100.0F ) | log10( 100.0D ) | log10( 100.0L ) | endl;
-        sout | "log1p:" | log1p( 1.0F ) | log1p( 1.0D ) | log1p( 1.0L ) | endl;
-        sout | "ilogb:" | ilogb( 1.0F ) | ilogb( 1.0D ) | ilogb( 1.0L ) | endl;
-        sout | "logb:" | logb( 8.0F ) | logb( 8.0D ) | logb( 8.0L ) | endl;
-        sout | "sqrt:" | sqrt( 1.0F ) | sqrt( 1.0D ) | sqrt( 1.0L ) | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0DL+1.0LI ) | endl;
-        sout | "cbrt:" | cbrt( 27.0F ) | cbrt( 27.0D ) | cbrt( 27.0L ) | endl;
-        sout | "hypot:" | hypot( 1.0F, -1.0F ) | hypot( 1.0D, -1.0D ) | hypot( 1.0L, -1.0L ) | endl;
 } // main

src/tests/math2.c

-              r3ef35bd
+              reba74ba
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Aug 11 15:40:04 2017
 // Update Count     : 81
+// Last Modified On : Thu May 24 21:06:10 2018
+// Update Count     : 82
 //
 …
         double d;
         long double l;
+        //---------------------- Logarithm ----------------------
+        sout | "log:" | log( 1.0F ) | log( 1.0D ) | log( 1.0L ) | log( 1.0F+1.0FI ) | log( 1.0D+1.0DI ) | log( 1.0DL+1.0LI ) | endl;
+        sout | "log2:" | log2( 8.0F ) | log2( 8.0D ) | log2( 8.0L ) | endl;
+        sout | "log10:" | log10( 100.0F ) | log10( 100.0D ) | log10( 100.0L ) | endl;
+        sout | "log1p:" | log1p( 1.0F ) | log1p( 1.0D ) | log1p( 1.0L ) | endl;
+        sout | "ilogb:" | ilogb( 1.0F ) | ilogb( 1.0D ) | ilogb( 1.0L ) | endl;
+        sout | "logb:" | logb( 8.0F ) | logb( 8.0D ) | logb( 8.0L ) | endl;
+        sout | "sqrt:" | sqrt( 1.0F ) | sqrt( 1.0D ) | sqrt( 1.0L ) | sqrt( 1.0F+1.0FI ) | sqrt( 1.0D+1.0DI ) | sqrt( 1.0DL+1.0LI ) | endl;
+        sout | "cbrt:" | cbrt( 27.0F ) | cbrt( 27.0D ) | cbrt( 27.0L ) | endl;
+        sout | "hypot:" | hypot( 1.0F, -1.0F ) | hypot( 1.0D, -1.0D ) | hypot( 1.0L, -1.0L ) | endl;
         //---------------------- Trigonometric ----------------------
 …
         sout | "atan2:" | atan2( 1.0F, 1.0F ) | atan2( 1.0D, 1.0D ) | atan2( 1.0L, 1.0L );
         sout | "atan:" | atan( 1.0F, 1.0F ) | atan( 1.0D, 1.0D ) | atan( 1.0L, 1.0L ) | endl;
-        //---------------------- Hyperbolic ----------------------
-        sout | "sinh:" | sinh( 1.0F ) | sinh( 1.0D ) | sinh( 1.0L ) | sinh( 1.0F+1.0FI ) | sinh( 1.0D+1.0DI ) | sinh( 1.0DL+1.0LI ) | endl;
-        sout | "cosh:" | cosh( 1.0F ) | cosh( 1.0D ) | cosh( 1.0L ) | cosh( 1.0F+1.0FI ) | cosh( 1.0D+1.0DI ) | cosh( 1.0DL+1.0LI ) | endl;
-        sout | "tanh:" | tanh( 1.0F ) | tanh( 1.0D ) | tanh( 1.0L ) | tanh( 1.0F+1.0FI ) | tanh( 1.0D+1.0DI ) | tanh( 1.0DL+1.0LI ) | endl;
-        sout | "acosh:" | acosh( 1.0F ) | acosh( 1.0D ) | acosh( 1.0L ) | acosh( 1.0F+1.0FI ) | acosh( 1.0D+1.0DI ) | acosh( 1.0DL+1.0LI ) | endl;
-        sout | "asinh:" | asinh( 1.0F ) | asinh( 1.0D ) | asinh( 1.0L ) | asinh( 1.0F+1.0FI ) | asinh( 1.0D+1.0DI ) | asinh( 1.0DL+1.0LI ) | endl;
-        sout | "atanh:" | atanh( 1.0F ) | atanh( 1.0D ) | atanh( 1.0L ) | atanh( 1.0F+1.0FI ) | atanh( 1.0D+1.0DI ) | atanh( 1.0DL+1.0LI ) | endl;
-        //---------------------- Error / Gamma ----------------------
-        sout | "erf:" | erf( 1.0F ) | erf( 1.0D ) | erf( 1.0L ) | endl;
-        sout | "erfc:" | erfc( 1.0F ) | erfc( 1.0D ) | erfc( 1.0L ) | endl;
-        sout | "lgamma:" | lgamma( 4.0F ) | lgamma( 4.0D ) | lgamma( 4.0L ) | endl;
-        int sign;
-        f = lgamma( 4.0F, &sign );
-        sout | "lgamma:" | f | sign;
-        d = lgamma( 4.0D, &sign );
-        sout | d | sign;
-        l = lgamma( 4.0L, &sign );
-        sout | l | sign | endl;
-        sout | "tgamma:" | tgamma( 4.0F ) | tgamma( 4.0D ) | tgamma( 4.0L ) | endl;
 } // main

src/tests/math3.c

-              r3ef35bd
+              reba74ba
 // Created On       : Fri Apr 22 14:59:21 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Aug 11 15:40:03 2017
 // Update Count     : 81
+// Last Modified On : Thu May 24 21:06:12 2018
+// Update Count     : 82
 //
 …
         long double l;
         //---------------------- Nearest Integer ----------------------
+        //---------------------- Hyperbolic ----------------------
+        sout | "floor:" | floor( 1.2F ) | floor( 1.2D ) | floor( 1.2L ) | endl;
+        sout | "ceil:" | ceil( 1.6F ) | ceil( 1.6D ) | ceil( 1.6L ) | endl;
+        sout | "trunc:" | trunc( 3.5F ) | trunc( 3.5D ) | trunc( 3.5L ) | endl;
+        sout | "rint:" | (float)rint( 1.5F ) | (double)rint( 1.5D ) | (long double)rint( 1.5L ) | endl;
+        sout | "rint:" | (long int)rint( 1.5F ) | (long int)rint( 1.5D ) | (long int)rint( 1.5L ) | endl;
+        sout | "rint:" | (long long int)rint( 1.5F ) | (long long int)rint( 1.5D ) | (long long int)rint( 1.5L ) | endl;
+        sout | "lrint:" | lrint( 1.5F ) | lrint( 1.5D ) | lrint( 1.5L ) | endl;
+        sout | "llrint:" | llrint( 1.5F ) | llrint( 1.5D ) | llrint( 1.5L ) | endl;
+        sout | "nearbyint:" | nearbyint( 3.5F ) | nearbyint( 3.5D ) | nearbyint( 3.5L ) | endl;
+        sout | "round:" | (float)round( 1.5F ) | (double)round( 1.5D ) | (long double)round( 1.5L ) | endl;
+        sout | "round:" | (long int)round( 1.5F ) | (long int)round( 1.5D ) | (long int)round( 1.5L ) | endl;
+        sout | "round:" | (long long int)round( 1.5F ) | (long long int)round( 1.5D ) | (long long int)round( 1.5L ) | endl;
+        sout | "lround:" | lround( 1.5F ) | lround( 1.5D ) | lround( 1.5L ) | endl;
+        sout | "llround:" | llround( 1.5F ) | llround( 1.5D ) | llround( 1.5L ) | endl;
+        sout | "sinh:" | sinh( 1.0F ) | sinh( 1.0D ) | sinh( 1.0L ) | sinh( 1.0F+1.0FI ) | sinh( 1.0D+1.0DI ) | sinh( 1.0DL+1.0LI ) | endl;
+        sout | "cosh:" | cosh( 1.0F ) | cosh( 1.0D ) | cosh( 1.0L ) | cosh( 1.0F+1.0FI ) | cosh( 1.0D+1.0DI ) | cosh( 1.0DL+1.0LI ) | endl;
+        sout | "tanh:" | tanh( 1.0F ) | tanh( 1.0D ) | tanh( 1.0L ) | tanh( 1.0F+1.0FI ) | tanh( 1.0D+1.0DI ) | tanh( 1.0DL+1.0LI ) | endl;
+        sout | "acosh:" | acosh( 1.0F ) | acosh( 1.0D ) | acosh( 1.0L ) | acosh( 1.0F+1.0FI ) | acosh( 1.0D+1.0DI ) | acosh( 1.0DL+1.0LI ) | endl;
+        sout | "asinh:" | asinh( 1.0F ) | asinh( 1.0D ) | asinh( 1.0L ) | asinh( 1.0F+1.0FI ) | asinh( 1.0D+1.0DI ) | asinh( 1.0DL+1.0LI ) | endl;
+        sout | "atanh:" | atanh( 1.0F ) | atanh( 1.0D ) | atanh( 1.0L ) | atanh( 1.0F+1.0FI ) | atanh( 1.0D+1.0DI ) | atanh( 1.0DL+1.0LI ) | endl;
         //---------------------- Manipulation ----------------------
+        //---------------------- Error / Gamma ----------------------
+        sout | "copysign:" | copysign( 1.0F, -1.0F ) | copysign( 1.0D, -1.0D ) | copysign( 1.0L, -1.0L ) | endl;
+        int exp;
+        f = frexp( 4.0F, &exp );
+        sout | "frexp:" | f | exp;
+        d = frexp( 4.0D, &exp );
+        sout | d | exp;
+        l = frexp( 4.0L, &exp );
+        sout | l | exp | endl;
+        sout | "ldexp:" | ldexp( 2.0F, 2 ) | ldexp( 2.0D, 2 ) | ldexp( 2.0L, 2 ) | endl;
+        float fi;
+        double di;
+        long double ldi;
+        f = modf( 2.3F, &fi );
+        sout | "modf:" | fi | f;
+        d = modf( 2.3D, &di );
+        sout | di | d;
+        l = modf( 2.3L, &ldi );
+        sout | ldi | l | endl;
+        sout | "modf:" | modf( 2.3F ) | modf( 2.3D ) | modf( 2.3L ) | endl;
+        sout | "nextafter:" | nextafter( 2.0F, 3.0F ) | nextafter( 2.0D, 3.0D ) | nextafter( 2.0L, 3.0L ) | endl;
+        sout | "nexttoward:" | nexttoward( 2.0F, 3.0F ) | nexttoward( 2.0D, 3.0D ) | nexttoward( 2.0L, 3.0L ) | endl;
+        sout | "scalbn:" | scalbn( 2.0F, 3 ) | scalbn( 2.0D, 3 ) | scalbn( 2.0L, 3 ) | endl;
+        sout | "scalbln:" | scalbln( 2.0F, 3L ) | scalbln( 2.0D, 3L ) | scalbln( 2.0L, 3L ) | endl;
+        sout | "erf:" | erf( 1.0F ) | erf( 1.0D ) | erf( 1.0L ) | endl;
+        sout | "erfc:" | erfc( 1.0F ) | erfc( 1.0D ) | erfc( 1.0L ) | endl;
+        sout | "lgamma:" | lgamma( 4.0F ) | lgamma( 4.0D ) | lgamma( 4.0L ) | endl;
+        int sign;
+        f = lgamma( 4.0F, &sign );
+        sout | "lgamma:" | f | sign;
+        d = lgamma( 4.0D, &sign );
+        sout | d | sign;
+        l = lgamma( 4.0L, &sign );
+        sout | l | sign | endl;
+        sout | "tgamma:" | tgamma( 4.0F ) | tgamma( 4.0D ) | tgamma( 4.0L ) | endl;
 } // main

src/tests/preempt_longrun/Makefile.am

r3ef35bd	reba74ba
17	17	repeats=10
18	18	max_time=600
19		preempt=1~~_000ul~~
	19	preempt=10ul\`ms
20	20	debug=-debug
21	21

src/tests/preempt_longrun/Makefile.in

r3ef35bd	reba74ba
450	450	repeats = 10
451	451	max_time = 600
452		preempt = 1~~_000ul~~
	452	preempt = 10ul\`ms
453	453	debug = -debug
454	454	REPEAT = ${abs_top_srcdir}/tools/repeat

src/tests/preempt_longrun/create.c

-              r3ef35bd
+              reba74ba
 #include <kernel>
 #include <thread>
+static const unsigned long N = 60_000ul;
+#include <time>
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
+#error PREEMPTION_RATE not defined in makefile
 #endif
 …
         return PREEMPTION_RATE;
+}
+static const unsigned long N = 60_000ul;
 thread worker_t {};

src/tests/preempt_longrun/enter.c

-              r3ef35bd
+              reba74ba
 #include <monitor>
 #include <thread>
+static const unsigned long N  = 2_100_000ul;
+#include <time>
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
+#error PREEMPTION_RATE not defined in makefile
 #endif
 …
         return PREEMPTION_RATE;
+}
+static const unsigned long N  = 2_100_000ul;
 monitor mon_t {};

src/tests/preempt_longrun/enter3.c

-              r3ef35bd
+              reba74ba
 #include <monitor>
 #include <thread>
+static const unsigned long N  = 500_000ul;
+#include <time>
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
+#error PREEMPTION_RATE not defined in makefile
 #endif
 …
         return PREEMPTION_RATE;
+}
+static const unsigned long N  = 500_000ul;
 monitor mon_t {};

src/tests/preempt_longrun/processor.c

-              r3ef35bd
+              reba74ba
 #include <kernel>
 #include <thread>
+static const unsigned long N = 5_000ul;
+#include <time>
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
+#error PREEMPTION_RATE not defined in makefile
 #endif
 …
         return PREEMPTION_RATE;
+}
+static const unsigned long N = 5_000ul;
 int main(int argc, char* argv[]) {

src/tests/preempt_longrun/stack.c

-              r3ef35bd
+              reba74ba
 #include <kernel>
+#include <math>
 #include <thread>
+#include <math>
+#include <time>
 #ifndef PREEMPTION_RATE
 #define PREEMPTION_RATE 10`ms
+#error PREEMPTION_RATE not defined in makefile
 #endif

src/tests/preempt_longrun/yield.c

-              r3ef35bd
+              reba74ba
 #include <kernel>
 #include <thread>
+#include <time>
+#ifndef PREEMPTION_RATE
+#error PREEMPTION_RATE not defined in makefile
+#endif
+Duration default_preemption() {
+        return PREEMPTION_RATE;
+}
 #ifdef LONG_TEST
 …
 static const unsigned long N = 325_000ul;
 #endif
-#ifndef PREEMPTION_RATE
-#define PREEMPTION_RATE 10`ms
-#endif
-Duration default_preemption() {
-        return PREEMPTION_RATE;
+}
 thread worker_t {};

src/tests/references.c

-              r3ef35bd
+              reba74ba
+}
-// --- temporary code needed to make array of references subscript work.
-extern "C" {
-  void ** __index(__attribute__ ((unused)) size_t sizeof_T, __attribute__ ((unused)) size_t alignof_T, void **x, ptrdiff_t y) {
-    return (void **)((char *)x+y*sizeof(void *));
+  }
-  void __ctor(void ***dst, void **src) {
-    *dst = src;
+  }
+}
-__attribute__((alias("__index"))) forall( dtype T | sized(T) ) T && ?[?]( T & * x, ptrdiff_t y );
-__attribute__((alias("__ctor"))) forall( dtype DT ) void ?{}( DT & * & dst, DT & * src);
-forall( dtype DT ) void ^?{}( DT & * & ) {}
-// --- end of temporary code
 int main() {
         int x = 123456, x2 = 789, *p1 = &x, **p2 = &p1, ***p3 = &p2,
 …
         *p3 = &p1;                          // change p2
         int y = 0, z = 11, & ar[3] = { x, y, z };    // initialize array of references
         &ar[1] = &z;                        // change reference array element
         typeof( ar[1] ) p = 3;              // is int, i.e., the type of referenced object
         typeof( &ar[1] ) q = &x;            // is int *, i.e., the type of pointer
         _Static_assert( sizeof( ar[1] ) == sizeof( int ), "Array type should be int." );   // is true, i.e., the size of referenced object
         _Static_assert( sizeof( &ar[1] ) == sizeof( int *), "Address of array should be int *." ); // is true, i.e., the size of a reference
+        // &ar[1] = &z;                        // change reference array element
+        // typeof( ar[1] ) p = 3;              // is int, i.e., the type of referenced object
+        // typeof( &ar[1] ) q = &x;            // is int *, i.e., the type of pointer
+        // _Static_assert( sizeof( ar[1] ) == sizeof( int ), "Array type should be int." );   // is true, i.e., the size of referenced object
+        // _Static_assert( sizeof( &ar[1] ) == sizeof( int *), "Address of array should be int *." ); // is true, i.e., the size of a reference
         ((int*&)&r3) = &x;                  // change r1, (&*)**r3
 …
 // tab-width: 4 //
 // End: //

src/tests/test.py

-              r3ef35bd
+              reba74ba
                         else :
                                 print('ERROR: No expected file for test %s, ignoring it' % testname, file=sys.stderr)
-        # make sure we have at least some test to run
-        if not tests :
-                print('ERROR: No valid test to run', file=sys.stderr)
-                sys.exit(1)
         return tests
 …
                 tests = validTests( options )
+        # make sure we have at least some test to run
+        if not tests :
+                print('ERROR: No valid test to run', file=sys.stderr)
+                sys.exit(1)
         # sort the test alphabetically for convenience
         tests.sort(key=lambda t: (t.arch if t.arch else '') + t.target())

src/tests/tuple/tupleAssign.c

r3ef35bd	reba74ba
48	48	int z;
49	49	} x;
50		X ?=?(X & x, double d) {}
	50	X ?=?(X & x, double d) { return x; }
51	51	[int, double, int] t;
52	52

Context Navigation

Legend:

Download in other formats: