Diff [af0805171a48b60a0cab3546131adbe3dbb9e7bc:28e58fd3419f0fb2ea29ff25f12b79f2d6153feb] for / – Cforall

src/CodeGen/CodeGenerator.cc

-              raf08051
+              r28e58fd
                         genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
                         output << ")" << endl;
+                        output << indent;
+                }
 …
                         for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
                                 updateLocation( *i );
+                                output << indent;
                                 (*i)->accept( *this );
                                 output << ";" << endl;
 …
                                 assert( obj );
                                 updateLocation( obj );
                                 output << mangleName( obj );
+                                output << indent << mangleName( obj );
                                 if ( obj->get_init() ) {
                                         output << " = ";
 …
         void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
+                // xxx - generate something reasonable for constructor/destructor pairs
+                output << "<ctorinit>";
+                // pseudo-output for constructor/destructor pairs
+                output << "<ctorinit>{" << std::endl << ++indent << "ctor: ";
+                maybeAccept( init->get_ctor(), *this );
+                output << ", " << std::endl << indent << "dtor: ";
+                maybeAccept( init->get_dtor(), *this );
+                output << std::endl << --indent << "}";
+        }
 …
                         if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
-                                switch ( opInfo.type ) {
-                                  case OT_PREFIXASSIGN:
-                                  case OT_POSTFIXASSIGN:
-                                  case OT_INFIXASSIGN:
-                                  case OT_CTOR:
-                                  case OT_DTOR:
+                                        {
-                                                assert( arg != applicationExpr->get_args().end() );
-                                                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( *arg ) ) {
-                                                        // remove & from first assignment/ctor argument
-                                                        *arg = addrExpr->get_arg();
-                                                } else {
-                                                        // no address-of operator, so must be a pointer - add dereference
-                                                        // NOTE: if the assertion starts to trigger, check that the application expr isn't being shared.
-                                                        // Since its arguments are modified here, this assertion most commonly triggers when the application
-                                                        // is visited multiple times.
-                                                        UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                                                        newExpr->get_args().push_back( *arg );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
-                                                        assertf( type, "First argument to a derefence must be a pointer. Ensure that expressions are not being shared." );
-                                                        newExpr->set_result( type->clone() );
-                                                        *arg = newExpr;
-                                                } // if
-                                                break;
+                                        }
-                                  default:
-                                        // do nothing
+                                        ;
-                                } // switch
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
 …
                 if ( castExpr->get_result()->isVoid() ) {
                         output << "(void)" ;
+                } else if ( ! castExpr->get_result()->get_lvalue() ) {
+                        // at least one result type of cast, but not an lvalue
+                } else {
+                        // at least one result type of cast.
+                        // Note: previously, lvalue casts were skipped. Since it's now impossible for the user to write
+                        // an lvalue cast, this has been taken out.
                         output << "(";
                         output << genType( castExpr->get_result(), "", pretty, genC );
                         output << ")";
-                } else {
-                        // otherwise, the cast is to an lvalue type, so the cast should be dropped, since the result of a cast is
-                        // never an lvalue in C
                 } // if
                 castExpr->get_arg()->accept( *this );
 …
                 extension( commaExpr );
                 output << "(";
+                if ( genC ) {
+                        // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
+                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
+                }
                 commaExpr->get_arg1()->accept( *this );
                 output << " , ";
                 commaExpr->get_arg2()->accept( *this );
                 output << ")";
+        }
+        void CodeGenerator::visit( TupleAssignExpr * tupleExpr ) {
+                assertf( ! genC, "TupleAssignExpr should not reach code generation." );
+                tupleExpr->stmtExpr->accept( *this );
+        }
 …
                 output << "(" << genType( compLitExpr->get_result(), "", pretty, genC ) << ")";
                 compLitExpr->get_initializer()->accept( *this );
+        }
+        void CodeGenerator::visit( UniqueExpr * unqExpr ) {
+                assertf( ! genC, "Unique expressions should not reach code generation." );
+                output << "unq<" << unqExpr->get_id() << ">{ ";
+                unqExpr->get_expr()->accept( *this );
+                output << " }";
+        }
 …
                 for ( Statement * stmt : stmts ) {
                         updateLocation( stmt );
             output << printLabels( stmt->get_labels() );
+                        output << printLabels( stmt->get_labels() );
                         if ( i+1 == numStmts ) {
                                 // last statement in a statement expression needs to be handled specially -
 …
         void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                Expression * expr = exprStmt->get_expr();
                 if ( genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
                         expr = new CastExpr( expr );
+                }
                 expr->accept( *this );
+                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
+                }
+                exprStmt->get_expr()->accept( *this );
                 output << ";";
+        }

src/CodeGen/CodeGenerator.h

raf08051	r28e58fd
74	74	virtual void visit( CommaExpr *commaExpr );
75	75	virtual void visit( CompoundLiteralExpr *compLitExpr );
	76	virtual void visit( UniqueExpr * );
	77	virtual void visit( TupleAssignExpr * tupleExpr );
76	78	virtual void visit( UntypedTupleExpr *tupleExpr );
77	79	virtual void visit( TupleExpr *tupleExpr );

src/CodeGen/GenType.cc

-              raf08051
+              r28e58fd
                 virtual void visit( PointerType *pointerType );
                 virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
                 virtual void visit( StructInstType *structInst );
                 virtual void visit( UnionInstType *unionInst );
 …
         void GenType::visit( ArrayType *arrayType ) {
                 genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+        }
+        void GenType::visit( ReferenceType *refType ) {
+                assert( refType->get_base() != 0);
+                assertf( ! genC, "Reference types should not reach code generation." );
+                handleQualifiers( refType );
+                typeString = "&" + typeString;
+                refType->get_base()->accept( *this );
+        }
 …
                         typeString = "_Atomic " + typeString;
                 } // if
+                if ( type->get_lvalue() && ! genC ) {
+                        // when not generating C code, print lvalue for debugging.
+                        typeString = "lvalue " + typeString;
+                }
+        }
 } // namespace CodeGen

src/CodeGen/OperatorTable.cc

-              raf08051
+              r28e58fd
 //
+#include <map>      // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>  // for pair
+#include <algorithm>  // for any_of
+#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>    // for pair
 #include "OperatorTable.h"
 …
                 } // if
+        }
+        /// determines if a given function name is one of the operator types between [begin, end)
+        template<typename Iterator>
+        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
+                OperatorInfo info;
+                if ( operatorLookup( funcName, info ) ) {
+                        return std::find( begin, end, info.type ) != end;
+                }
+                return false;
+        }
+        bool isConstructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isDestructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isAssignment( const std::string & funcName ) {
+                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isCtorDtor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isCtorDtorAssign( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
 } // namespace CodeGen

src/CodeGen/OperatorTable.h

-              raf08051
+              r28e58fd
 // file "LICENCE" distributed with Cforall.
 //
 // OperatorTable.h --
+// OperatorTable.h --
 //
 // Author           : Richard C. Bilson
 …
         bool operatorLookup( std::string funcName, OperatorInfo &info );
+        bool isConstructor( const std::string & );
+        bool isDestructor( const std::string & );
+        bool isAssignment( const std::string & );
+        bool isCtorDtor( const std::string & );
+        bool isCtorDtorAssign( const std::string & );
 } // namespace CodeGen

src/Common/PassVisitor.h

-              raf08051
+              r28e58fd
         virtual void visit( PointerType *pointerType ) override final;
         virtual void visit( ArrayType *arrayType ) override final;
+        virtual void visit( ReferenceType *referenceType ) override final;
         virtual void visit( FunctionType *functionType ) override final;
         virtual void visit( StructInstType *aggregateUseType ) override final;
 …
         virtual Type* mutate( PointerType *pointerType ) override final;
         virtual Type* mutate( ArrayType *arrayType ) override final;
+        virtual Type* mutate( ReferenceType *referenceType ) override final;
         virtual Type* mutate( FunctionType *functionType ) override final;
         virtual Type* mutate( StructInstType *aggregateUseType ) override final;

src/Common/PassVisitor.impl.h

-              raf08051
+              r28e58fd
 template< typename pass_type >
+void PassVisitor< pass_type >::visit( ReferenceType * node ) {
+        VISIT_BODY( node );
+}
+template< typename pass_type >
 void PassVisitor< pass_type >::visit( FunctionType * node ) {
         VISIT_BODY( node );
 …
 template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
+        MUTATE_BODY( Type, node );
+}
+template< typename pass_type >
 Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
         MUTATE_BODY( Type, node );

src/Common/utility.h

-              raf08051
+              r28e58fd
 template< typename T1, typename T2 >
 struct group_iterate_t {
         group_iterate_t( const T1 & v1, const T2 & v2 ) : args(v1, v2) {
                 assertf(v1.size() == v2.size(), "group iteration requires containers of the same size.");
+        group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
+                assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%zd, %zd>.", v1.size(), v2.size());
         };
 …
 };
+/// performs bounds check to ensure that all arguments are of the same length.
 template< typename... Args >
 group_iterate_t<Args...> group_iterate( Args &&... args ) {
+        return group_iterate_t<Args...>(std::forward<Args>( args )...);
+        return group_iterate_t<Args...>(false, std::forward<Args>( args )...);
+}
+/// does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
+template< typename... Args >
+group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
+        return group_iterate_t<Args...>(true, std::forward<Args>( args )...);
+}

src/Concurrency/Keywords.cc

-              raf08051
+              r28e58fd
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, map_range
+#include "InitTweak/InitTweak.h"   // for isConstructor
+#include "CodeGen/OperatorTable.h" // for isConstructor
+#include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
 …
                         LinkageSpec::Cforall,
                         nullptr,
                         new PointerType(
+                        new ReferenceType(
                                 noQualifiers,
                                 new StructInstType(
 …
                 //Makes sure it's not a copy
                 PointerType* pty = dynamic_cast< PointerType * >( ty );
                 if( ! pty ) throw SemanticError( "Mutex argument must be of pointer/reference type ", arg );
+                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
+                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
                 //Make sure the we are pointing directly to a type
+                Type* base = pty->get_base();
+                if(  dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                Type* base = rty->get_base();
+                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
                 //Make sure that typed isn't mutex
 …
                 Visitor::visit(decl);
                 if( ! InitTweak::isConstructor(decl->get_name()) ) return;
+                if( ! CodeGen::isConstructor(decl->get_name()) ) return;
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
+                auto ptr = dynamic_cast< PointerType * >( param->get_type() );
+                // if( ptr ) std::cerr << "FRED1" << std::endl;
+                auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
+                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
                 // if( type ) std::cerr << "FRED2" << std::endl;
                 if( type && type->get_baseStruct()->is_thread() ) {

src/GenPoly/Box.cc

-              raf08051
+              r28e58fd
 #include "Box.h"
+#include "CodeGen/OperatorTable.h"
 #include "Common/ScopedMap.h"            // for ScopedMap, ScopedMap<>::iter...
 #include "Common/SemanticError.h"        // for SemanticError
 …
                         // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions
                         if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) {
                                 if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
+                                if ( CodeGen::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
                                         assert( assign->get_args().size() == 2 );
                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) {
 …
+                                                }
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct" );
+                                                throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType );
+                                        }
+                                }
 …
                                                 } // if
                                                 if ( baseType1 || baseType2 ) {
+                                                        delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
                                                         if ( appExpr->get_env() ) {
 …
                                                 assert( ! appExpr->get_args().empty() );
                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                        // remove dereference from polymorphic types since they are boxed.
                                                         Expression *ret = appExpr->get_args().front();
+                                                        // fix expr type to remove pointer
                                                         delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
 …
                         assert( appExpr->get_function()->has_result() );
                         PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
                         FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
 …
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
                                                                 assert( appExpr->get_function()->has_result() );
                                                                 PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
                                                                 FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                                                                assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
                                                         } // if
 …
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
+                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
+                        // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
-                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
 …
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
                                         std::string adapterName = makeAdapterName( mangleName );
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
+                                        // adapter may not be used in body, pass along with unused attribute.
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
+                                }
 …
                         std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
                         std::list< DeclarationWithType *> inferredParams;
+                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
+                        // size/align/offset parameters may not be used in body, pass along with unused attribute.
+                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0,
+                                           { new Attribute( "unused" ) } );
                         ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
 …
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
 //      *assert = (*assert)->acceptMutator( *this );
+                                        // assertion parameters may not be used in body, pass along with unused attribute.
+                                        (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
                                         inferredParams.push_back( *assert );
+                                }

src/GenPoly/InstantiateGeneric.cc

-              raf08051
+              r28e58fd
                 /// Should not make use of type environment to replace types of function parameter and return values.
                 bool inFunctionType = false;
+                /// Index of current member, used to recreate MemberExprs with the member from an instantiation
+                int memberIndex = -1;
                 GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {}
 …
                 Type* postmutate( UnionInstType *inst );
+                void premutate( __attribute__((unused)) FunctionType * ftype ) {
+                // fix MemberExprs to use the member from the instantiation
+                void premutate( MemberExpr * memberExpr );
+                Expression * postmutate( MemberExpr * memberExpr );
+                void premutate( FunctionType * ) {
                         GuardValue( inFunctionType );
                         inFunctionType = true;
 …
+        }
+        namespace {
+                bool isGenericType( Type * t ) {
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) {
+                                return ! inst->parameters.empty();
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
+                                return ! inst->parameters.empty();
+                        }
+                        return false;
+                }
+                AggregateDecl * getAggr( Type * t ) {
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) {
+                                return inst->baseStruct;
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
+                                return inst->baseUnion;
+                        }
+                        assertf( false, "Non-aggregate type: %s", toString( t ).c_str() );
+                }
+        }
+        void GenericInstantiator::premutate( MemberExpr * memberExpr ) {
+                GuardValue( memberIndex );
+                memberIndex = -1;
+                if ( isGenericType( memberExpr->aggregate->result ) ) {
+                        // find the location of the member
+                        AggregateDecl * aggr = getAggr( memberExpr->aggregate->result );
+                        std::list< Declaration * > & members = aggr->members;
+                        memberIndex = std::distance( members.begin(), std::find( members.begin(), members.end(), memberExpr->member ) );
+                        assertf( memberIndex < (int)members.size(), "Could not find member %s in generic type %s", toString( memberExpr->member ).c_str(), toString( memberExpr->aggregate ).c_str() );
+                }
+        }
+        Expression * GenericInstantiator::postmutate( MemberExpr * memberExpr ) {
+                if ( memberIndex != -1 ) {
+                        // using the location from the generic type, find the member in the instantiation and rebuild the member expression
+                        AggregateDecl * aggr = getAggr( memberExpr->aggregate->result );
+                        assertf( memberIndex < (int)aggr->members.size(), "Instantiation somehow has fewer members than the generic type." );
+                        Declaration * member = *std::next( aggr->members.begin(), memberIndex );
+                        assertf( member->name == memberExpr->member->name, "Instantiation has different member order than the generic type. %s / %s", toString( member ).c_str(), toString( memberExpr->member ).c_str() );
+                        DeclarationWithType * field = safe_dynamic_cast< DeclarationWithType * >( member );
+                        MemberExpr * ret = new MemberExpr( field, memberExpr->aggregate->clone() );
+                        std::swap( ret->env, memberExpr->env );
+                        delete memberExpr;
+                        return ret;
+                }
+                return memberExpr;
+        }
         void GenericInstantiator::beginScope() {
                 instantiations.beginScope();

src/GenPoly/Lvalue.cc

-              raf08051
+              r28e58fd
 #include <string>                        // for string
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"        // for SemanticError
 #include "GenPoly.h"                     // for isPolyType
 #include "Lvalue.h"
 #include "Parser/LinkageSpec.h"          // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
 #include "ResolvExpr/Unify.h"            // for unify
+#include "ResolvExpr/typeops.h"
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"              // for Indexer
 #include "SynTree/Declaration.h"         // for Declaration, FunctionDecl
 …
 #include "SynTree/Visitor.h"             // for Visitor, acceptAll
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
 namespace GenPoly {
         namespace {
+                /// Replace uses of lvalue returns with appropriate pointers
+                class Pass1 : public Mutator {
+                  public:
+                        Pass1();
+                        virtual Expression *mutate( ApplicationExpr *appExpr );
+                        virtual Statement *mutate( ReturnStmt *appExpr );
+                        virtual DeclarationWithType *mutate( FunctionDecl *funDecl );
+                  private:
+                        DeclarationWithType* retval;
+                };
+                /// Replace declarations of lvalue returns with appropriate pointers
+                class Pass2 : public Visitor {
+                  public:
+                        virtual void visit( FunctionType *funType );
+                  private:
+                // TODO: fold this into the general createDeref function??
+                Expression * mkDeref( Expression * arg ) {
+                        if ( SymTab::dereferenceOperator ) {
+                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
+                                deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
+                                Type * base = InitTweak::getPointerBase( arg->get_result() );
+                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
+                                ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
+                                delete ret->get_result();
+                                ret->set_result( base->clone() );
+                                ret->get_result()->set_lvalue( true );
+                                return ret;
+                        } else {
+                                return UntypedExpr::createDeref( arg );
+                        }
+                }
+                struct ReferenceConversions final {
+                        Expression * postmutate( CastExpr * castExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                };
+                /// Intrinsic functions that take reference parameters don't REALLY take reference parameters -- their reference arguments must always be implicitly dereferenced.
+                struct FixIntrinsicArgs final {
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                };
+                struct FixIntrinsicResult final : public WithGuards {
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                        void premutate( FunctionDecl * funcDecl );
+                        bool inIntrinsic = false;
+                };
+                /// Replace reference types with pointer types
+                struct ReferenceTypeElimination final {
+                        Type * postmutate( ReferenceType * refType );
                 };
 …
                 /// https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Lvalues.html#Lvalues
                 /// Replaces &(a,b) with (a, &b), &(a ? b : c) with (a ? &b : &c)
+                class GeneralizedLvalue : public Mutator {
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( MemberExpr * memExpr );
+                        virtual Expression * mutate( AddressExpr * addressExpr );
+                struct GeneralizedLvalue final : public WithVisitorRef<GeneralizedLvalue> {
+                        Expression * postmutate( AddressExpr * addressExpr );
+                        Expression * postmutate( MemberExpr * memExpr );
                         template<typename Func>
                         Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
+                /// Removes redundant &*/*& pattern that this pass can generate
+                struct CollapseAddrDeref final {
+                        Expression * postmutate( AddressExpr * addressExpr );
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                };
+                struct AddrRef final : public WithGuards {
+                        void premutate( AddressExpr * addrExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                        void premutate( Expression * expr );
+                        bool first = true;
+                        bool current = false;
+                        int refDepth = 0;
+                };
         } // namespace
+        static bool referencesEliminated = false;
+        // used by UntypedExpr::createDeref to determine whether result type of dereference should be ReferenceType or value type.
+        bool referencesPermissable() {
+                return ! referencesEliminated;
+        }
         void convertLvalue( std::list< Declaration* >& translationUnit ) {
+                Pass1 p1;
+                Pass2 p2;
+                GeneralizedLvalue genLval;
+                mutateAll( translationUnit, p1 );
+                acceptAll( translationUnit, p2 );
+                PassVisitor<ReferenceConversions> refCvt;
+                PassVisitor<ReferenceTypeElimination> elim;
+                PassVisitor<GeneralizedLvalue> genLval;
+                PassVisitor<FixIntrinsicArgs> fixer;
+                PassVisitor<CollapseAddrDeref> collapser;
+                PassVisitor<AddrRef> addrRef;
+                PassVisitor<FixIntrinsicResult> intrinsicResults;
+                mutateAll( translationUnit, intrinsicResults );
+                mutateAll( translationUnit, addrRef );
+                mutateAll( translationUnit, refCvt );
+                mutateAll( translationUnit, fixer );
+                mutateAll( translationUnit, collapser );
                 mutateAll( translationUnit, genLval );
+                mutateAll( translationUnit, elim );  // last because other passes need reference types to work
+                // from this point forward, no other pass should create reference types.
+                referencesEliminated = true;
+        }
         Expression * generalizedLvalue( Expression * expr ) {
                 GeneralizedLvalue genLval;
+                PassVisitor<GeneralizedLvalue> genLval;
                 return expr->acceptMutator( genLval );
+        }
         namespace {
+                Type* isLvalueRet( FunctionType *function ) {
+                        if ( function->get_returnVals().empty() ) return 0;
+                        Type *ty = function->get_returnVals().front()->get_type();
+                        return ty->get_lvalue() ? ty : 0;
+                }
+                bool isIntrinsicApp( ApplicationExpr *appExpr ) {
+                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
+                                return varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic;
+                        } else {
+                                return false;
+                        } // if
+                }
+                Pass1::Pass1() {
+                }
+                DeclarationWithType * Pass1::mutate( FunctionDecl *funcDecl ) {
+                        if ( funcDecl->get_statements() ) {
+                                DeclarationWithType* oldRetval = retval;
+                                retval = 0;
+                                if ( ! LinkageSpec::isBuiltin( funcDecl->get_linkage() ) && isLvalueRet( funcDecl->get_functionType() ) ) {
+                                        retval = funcDecl->get_functionType()->get_returnVals().front();
+                                }
+                                // fix expressions and return statements in this function
+                                funcDecl->set_statements( funcDecl->get_statements()->acceptMutator( *this ) );
+                                retval = oldRetval;
+                        } // if
+                        return funcDecl;
+                }
+                Expression * Pass1::mutate( ApplicationExpr *appExpr ) {
+                        appExpr->get_function()->acceptMutator( *this );
+                        mutateAll( appExpr->get_args(), *this );
+                        PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                        Type *funType = isLvalueRet( function );
+                        if ( funType && ! isIntrinsicApp( appExpr ) ) {
+                                Expression *expr = appExpr;
+                                Type *appType = appExpr->get_result();
+                                if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
+                                        // make sure cast for polymorphic type is inside dereference
+                                        expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) );
+                                }
+                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                deref->set_result( appType->clone() );
+                                appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
+                                deref->get_args().push_back( expr );
+                                return deref;
+                        } else {
+                                return appExpr;
+                        } // if
+                }
+                Statement * Pass1::mutate(ReturnStmt *retStmt) {
+                        if ( retval && retStmt->get_expr() ) {
+                                if ( retStmt->get_expr()->get_result()->get_lvalue() ) {
+                                        // ***** Code Removal ***** because casts may be stripped already
+                                        // strip casts because not allowed to take address of cast
+                                        // while ( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
+                                        //      retStmt->set_expr( castExpr->get_arg() );
+                                        //      retStmt->get_expr()->set_env( castExpr->get_env() );
+                                        //      castExpr->set_env( 0 );
+                                        //      castExpr->set_arg( 0 );
+                                        //      delete castExpr;
+                                        // } // while
+                                        retStmt->set_expr( new AddressExpr( retStmt->get_expr()->acceptMutator( *this ) ) );
+                // true for intrinsic function calls that return a reference
+                bool isIntrinsicReference( Expression * expr ) {
+                        if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
+                                std::string fname = InitTweak::getFunctionName( untyped );
+                                // known intrinsic-reference prelude functions
+                                return fname == "*?" || fname == "?[?]";
+                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
+                                if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
+                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
+                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
+                                        Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
+                                        return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
+                                }
+                        }
+                        return false;
+                }
+                Expression * FixIntrinsicResult::postmutate( ApplicationExpr * appExpr ) {
+                        if ( isIntrinsicReference( appExpr ) ) {
+                                // eliminate reference types from intrinsic applications - now they return lvalues
+                                Type * result = appExpr->get_result();
+                                appExpr->set_result( result->stripReferences()->clone() );
+                                appExpr->get_result()->set_lvalue( true );
+                                if ( ! inIntrinsic ) {
+                                        // when not in an intrinsic function, add a cast to
+                                        // don't add cast when in an intrinsic function, since they already have the cast
+                                        Expression * ret = new CastExpr( appExpr, result );
+                                        ret->set_env( appExpr->get_env() );
+                                        appExpr->set_env( nullptr );
+                                        return ret;
+                                }
+                                delete result;
+                        }
+                        return appExpr;
+                }
+                void FixIntrinsicResult::premutate( FunctionDecl * funcDecl ) {
+                        GuardValue( inIntrinsic );
+                        inIntrinsic =  funcDecl->linkage == LinkageSpec::Intrinsic;
+                }
+                Expression * FixIntrinsicArgs::postmutate( ApplicationExpr * appExpr ) {
+                        // intrinsic functions don't really take reference-typed parameters, so they require an implicit dereference on their arguments.
+                        if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
+                                FunctionType * ftype = GenPoly::getFunctionType( function->get_type() );
+                                assertf( ftype, "Function declaration does not have function type." );
+                                // can be of differing lengths only when function is variadic
+                                assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
+                                unsigned int i = 0;
+                                const unsigned int end = ftype->get_parameters().size();
+                                for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
+                                        if (i == end) break;
+                                        Expression *& arg = std::get<0>( p );
+                                        Type * formal = std::get<1>( p )->get_type();
+                                        PRINT(
+                                                std::cerr << "pair<0>: " << arg << std::endl;
+                                                std::cerr << "pair<1>: " << formal << std::endl;
+                                        )
+                                        if ( dynamic_cast<ReferenceType*>( formal ) ) {
+                                                if ( isIntrinsicReference( arg ) ) { // do not combine conditions, because that changes the meaning of the else if
+                                                        if ( function->get_linkage() != LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references
+                                                                // if argument is dereference or array subscript, the result isn't REALLY a reference, so it's not necessary to fix the argument
+                                                                PRINT(
+                                                                        std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
+                                                                )
+                                                                arg = new AddressExpr( arg );
+                                                        }
+                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
+                                                        // std::cerr << "===adding deref to arg" << std::endl;
+                                                        // if the parameter is a reference, add a dereference to the reference-typed argument.
+                                                        Type * baseType = InitTweak::getPointerBase( arg->get_result() );
+                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
+                                                        PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
+                                                        delete arg->get_result();
+                                                        arg->set_result( ptrType );
+                                                        arg = mkDeref( arg );
+                                                }
+                                        }
+                                        ++i;
+                                }
+                        }
+                        return appExpr;
+                }
+                // idea: &&&E: get outer &, inner &
+                // at inner &, record depth D of reference type
+                // at outer &, add D derefs.
+                void AddrRef::premutate( Expression * ) {
+                        GuardValue( current );
+                        GuardValue( first );
+                        current = false;
+                        first = true;
+                }
+                void AddrRef::premutate( AddressExpr * ) {
+                        GuardValue( current );
+                        GuardValue( first );
+                        current = first;
+                        first = false;
+                        if ( current ) {
+                                GuardValue( refDepth );
+                                refDepth = 0;
+                        }
+                }
+                Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
+                        if ( refDepth == 0 ) {
+                                if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) {
+                                        // try to avoid ?[?]
+                                        refDepth = addrExpr->get_arg()->get_result()->referenceDepth();
+                                }
+                        }
+                        if ( current ) {
+                                Expression * ret = addrExpr;
+                                while ( refDepth ) {
+                                        ret = mkDeref( ret );
+                                        refDepth--;
+                                }
+                                return ret;
+                        }
+                        return addrExpr;
+                }
+                Expression * ReferenceConversions::postmutate( AddressExpr * addrExpr ) {
+                        // Inner expression may have been lvalue to reference conversion, which becomes an address expression.
+                        // In this case, remove the outer address expression and return the argument.
+                        // TODO: It's possible that this might catch too much and require a more sophisticated check.
+                        return addrExpr;
+                }
+                Expression * ReferenceConversions::postmutate( CastExpr * castExpr ) {
+                        // xxx - is it possible to convert directly between reference types with a different base? E.g.,
+                        //   int x;
+                        //   (double&)x;
+                        // At the moment, I am working off of the assumption that this is illegal, thus the cast becomes redundant
+                        // after this pass, so trash the cast altogether. If that changes, care must be taken to insert the correct
+                        // pointer casts in the right places.
+                        // conversion to reference type
+                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
+                                (void)refType;
+                                if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                                        // nothing to do if casting from reference to reference.
+                                        (void)otherRef;
+                                        PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; )
+                                        if ( isIntrinsicReference( castExpr->get_arg() ) ) {
+                                                Expression * callExpr = castExpr->get_arg();
+                                                PRINT(
+                                                        std::cerr << "but arg is deref -- &" << std::endl;
+                                                        std::cerr << callExpr << std::endl;
+                                                )
+                                                callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
+                                                delete callExpr->get_result();
+                                                callExpr->set_result( refType->clone() );
+                                                // move environment out to new top-level
+                                                callExpr->set_env( castExpr->get_env() );
+                                                castExpr->set_arg( nullptr );
+                                                castExpr->set_env( nullptr );
+                                                delete castExpr;
+                                                return callExpr;
+                                        }
+                                        int depth1 = refType->referenceDepth();
+                                        int depth2 = otherRef->referenceDepth();
+                                        int diff = depth1-depth2;
+                                        if ( diff == 0 ) {
+                                                assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
+                                                PRINT( std::cerr << castExpr << std::endl; )
+                                                return castExpr;
+                                        } else if ( diff < 0 ) {
+                                                Expression * ret = castExpr->get_arg();
+                                                for ( int i = 0; i < diff; ++i ) {
+                                                        ret = mkDeref( ret );
+                                                }
+                                                ret->set_env( castExpr->get_env() );
+                                                delete ret->get_result();
+                                                ret->set_result( castExpr->get_result() );
+                                                castExpr->set_env( nullptr );
+                                                castExpr->set_arg( nullptr );
+                                                castExpr->set_result( nullptr );
+                                                delete castExpr;
+                                                return ret;
+                                        } else if ( diff > 0 ) {
+                                                Expression * ret = castExpr->get_arg();
+                                                for ( int i = 0; i < diff; ++i ) {
+                                                        ret = new AddressExpr( ret );
+                                                }
+                                                ret->set_env( castExpr->get_env() );
+                                                delete ret->get_result();
+                                                ret->set_result( castExpr->get_result() );
+                                                castExpr->set_env( nullptr );
+                                                castExpr->set_arg( nullptr );
+                                                castExpr->set_result( nullptr );
+                                                delete castExpr;
+                                                return ret;
+                                        }
+                                        assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
+                                        PRINT( std::cerr << castExpr << std::endl; )
+                                        return castExpr;
+                                } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
+                                        // conversion from lvalue to reference
+                                        // xxx - keep cast, but turn into pointer cast??
+                                        // xxx - memory
+                                        PRINT(
+                                                std::cerr << "convert lvalue to reference -- &" << std::endl;
+                                                std::cerr << castExpr->get_arg() << std::endl;
+                                        )
+                                        AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
+                                        if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
+                                                // must keep cast if cast-to type is different from the actual type
+                                                castExpr->set_arg( ret );
+                                                return castExpr;
+                                        }
+                                        ret->set_env( castExpr->get_env() );
+                                        delete ret->get_result();
+                                        ret->set_result( castExpr->get_result() );
+                                        castExpr->set_env( nullptr );
+                                        castExpr->set_arg( nullptr );
+                                        castExpr->set_result( nullptr );
+                                        delete castExpr;
+                                        return ret;
                                 } else {
+                                        throw SemanticError( "Attempt to return non-lvalue from an lvalue-qualified function" );
+                                } // if
+                        } // if
+                        return retStmt;
+                }
+                void Pass2::visit( FunctionType *funType ) {
+                        std::string typeName;
+                        if ( isLvalueRet( funType ) ) {
+                                DeclarationWithType *retParm = funType->get_returnVals().front();
+                                // make a new parameter that is a pointer to the type of the old return value
+                                retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
+                        } // if
+                        Visitor::visit( funType );
+                                        // rvalue to reference conversion -- introduce temporary
+                                }
+                                assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
+                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                                (void)refType;
+                                // conversion from reference to rvalue
+                                PRINT(
+                                        std::cerr << "convert reference to rvalue -- *" << std::endl;
+                                        std::cerr << "was = " << castExpr << std::endl;
+                                )
+                                Expression * ret = castExpr->get_arg();
+                                TypeSubstitution * env = castExpr->get_env();
+                                castExpr->set_env( nullptr );
+                                if ( ! isIntrinsicReference( ret ) ) {
+                                        // dereference if not already dereferenced
+                                        ret = mkDeref( ret );
+                                }
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
+                                        // can remove cast if types are compatible, changing expression type to value type
+                                        ret->set_result( castExpr->get_result()->clone() );
+                                        castExpr->set_arg( nullptr );
+                                        delete castExpr;
+                                } else {
+                                        // must keep cast if types are different
+                                        castExpr->set_arg( ret );
+                                        ret = castExpr;
+                                }
+                                ret->set_env( env );
+                                PRINT( std::cerr << "now: " << ret << std::endl; )
+                                return ret;
+                        }
+                        return castExpr;
+                }
+                Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
+                        Type * base = refType->get_base();
+                        Type::Qualifiers qualifiers = refType->get_qualifiers();
+                        refType->set_base( nullptr );
+                        delete refType;
+                        return new PointerType( qualifiers, base );
+                }
 …
                                 Expression * arg1 = commaExpr->get_arg1()->clone();
                                 Expression * arg2 = commaExpr->get_arg2()->clone();
                                 Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
                                 ret->set_env( expr->get_env() );
                                 expr->set_env( nullptr );
                                 delete expr;
                                 return ret->acceptMutator( *this );
+                                return ret;
                         } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
                                 Expression * arg1 = condExpr->get_arg1()->clone();
                                 Expression * arg2 = condExpr->get_arg2()->clone();
                                 Expression * arg3 = condExpr->get_arg3()->clone();
                                 ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
                                 ret->set_env( expr->get_env() );
                                 expr->set_env( nullptr );
 …
                                 unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
                                 ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
                                 return ret->acceptMutator( *this );
+                                return ret;
+                        }
                         return expr;
+                }
+                Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+                        Parent::mutate( memExpr );
+                Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
                         return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
                         return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
+                }
+                Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) {
+                        Expression * arg = addrExpr->get_arg();
+                        if ( isIntrinsicReference( arg ) ) {
+                                std::string fname = InitTweak::getFunctionName( arg );
+                                if ( fname == "*?" ) {
+                                        Expression *& arg0 = InitTweak::getCallArg( arg, 0 );
+                                        Expression * ret = arg0;
+                                        ret->set_env( addrExpr->get_env() );
+                                        arg0 = nullptr;
+                                        addrExpr->set_env( nullptr );
+                                        delete addrExpr;
+                                        return ret;
+                                }
+                        }
+                        return addrExpr;
+                }
+                Expression * CollapseAddrDeref::postmutate( ApplicationExpr * appExpr ) {
+                        if ( isIntrinsicReference( appExpr ) ) {
+                                std::string fname = InitTweak::getFunctionName( appExpr );
+                                if ( fname == "*?" ) {
+                                        Expression * arg = InitTweak::getCallArg( appExpr, 0 );
+                                        // xxx - this isn't right, because it can remove casts that should be there...
+                                        // while ( CastExpr * castExpr = dynamic_cast< CastExpr * >( arg ) ) {
+                                        //      arg = castExpr->get_arg();
+                                        // }
+                                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) {
+                                                Expression * ret = addrExpr->get_arg();
+                                                ret->set_env( appExpr->get_env() );
+                                                addrExpr->set_arg( nullptr );
+                                                appExpr->set_env( nullptr );
+                                                delete appExpr;
+                                                return ret;
+                                        }
+                                }
+                        }
+                        return appExpr;
+                }
         } // namespace

src/GenPoly/Lvalue.h

-              raf08051
+              r28e58fd
         void convertLvalue( std::list< Declaration* >& translationUnit );
+        /// true after reference types have been eliminated from the source code. After this point, reference types should not be added to the AST.
+        bool referencesPermissable();
         /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
         Expression * generalizedLvalue( Expression * expr );

src/GenPoly/Specialize.cc

-              raf08051
+              r28e58fd
                         // conversion of 0 (null) to function type does not require tuple specialization
                         if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );
+                        FunctionType * aftype = getFunctionType( actualType->stripReferences() );
+                        assertf( aftype, "formal type is a function type, but actual type is not: %s", toString( actualType ).c_str() );
                         // Can't tuple specialize if parameter sizes deeply-differ.
                         if ( functionParameterSize( fftype ) != functionParameterSize( aftype ) ) return false;

src/InitTweak/FixInit.cc

-              raf08051
+              r28e58fd
 #include "CodeGen/GenType.h"           // for genPrettyType
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
 …
                         SemanticError errors;
                   private:
-                        void handleFirstParam( Expression * firstParam );
                         template< typename... Params >
                         void emit( CodeLocation, const Params &... params );
 …
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
                                         if ( isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
                                                 PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 );
                                                 if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                                                assert( t1 );
+                                                if ( ResolvExpr::typesCompatible( t1, t2, SymTab::Indexer() ) ) {
                                                         // optimization: don't need to copy construct in order to call a copy constructor
                                                         return appExpr;
                                                 } // if
                                         } else if ( isDestructor( funcDecl->get_name() ) ) {
+                                        } else if ( CodeGen::isDestructor( funcDecl->get_name() ) ) {
                                                 // correctness: never copy construct arguments to a destructor
                                                 return appExpr;
 …
                 bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
                         return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
 …
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! result->get_lvalue() ) {
+                                if ( ! dynamic_cast< ReferenceType * >( result ) ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
 …
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_lvalue() ) {
-                                        // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
-                                        // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
-                                        // type of the return temporary from T to T* to properly capture the return value. Then dereference
-                                        // the result of the comma expression, since the lvalue returning call was originally wrapped with
-                                        // an AddressExpr.  Effectively, this turns
-                                        //   lvalue T f();
-                                        //   &*f();
-                                        // into
-                                        //   T * f();
-                                        //   T * tmp_cp_retN;
-                                        //   &*(tmp_cp_retN = &*f(), tmp_cp_retN);              // the first * and second & are generated here
-                                        // which work out in terms of types, but is pretty messy. It would be nice to find a better way.
-                                        assign->get_args().back() = new AddressExpr( assign->get_args().back() );
-                                        returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) );
-                                        retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) );
-                                        retExpr = UntypedExpr::createDeref( retExpr );
-                                } // if
                                 // move env from callExpr to retExpr
                                 retExpr->set_env( callExpr->get_env() );
 …
                         if ( ! funcDecl ) return false;
                         if ( ! funcDecl->get_statements() ) return false;
                         return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                        return CodeGen::isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                }
 …
                         function = funcDecl;
                         isCtor = isConstructor( function->get_name() );
+                        isCtor = CodeGen::isConstructor( function->get_name() );
                         if ( checkWarnings( function ) ) {
                                 FunctionType * type = function->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
                                 PointerType * ptrType = safe_dynamic_cast< PointerType * > ( thisParam->get_type() );
                                 StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
+                                Type * thisType = getPointerBase( thisParam->get_type() );
+                                StructInstType * structType = dynamic_cast< StructInstType * >( thisType );
                                 if ( structType ) {
                                         structDecl = structType->get_baseStruct();
 …
                         if ( ! unhandled.empty() ) {
                                 // need to explicitly re-add function parameters in order to resolve copy constructors
+                                // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
                                 enterScope();
                                 maybeAccept( function->get_functionType(), *this );
 …
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) );
                                         Expression * arg2 = 0;
                                         if ( isCopyConstructor( function ) ) {
 …
+                                        }
                                         InitExpander srcParam( arg2 );
+                                        SymTab::genImplicitCall( srcParam, new MemberExpr( field, deref ), function->get_name(), back_inserter( stmt ), field, isCtor );
+                                        // cast away reference type and construct field.
+                                        Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() );
+                                        Expression * memberDest = new MemberExpr( field, thisExpr );
+                                        SymTab::genImplicitCall( srcParam, memberDest, function->get_name(), back_inserter( stmt ), field, isCtor );
                                         assert( stmt.size() <= 1 );
 …
+                }
+                /// true if expr is effectively just the 'this' parameter
+                bool isThisExpression( Expression * expr, DeclarationWithType * thisParam ) {
+                        // TODO: there are more complicated ways to pass 'this' to a constructor, e.g. &*, *&, etc.
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
+                                return varExpr->get_var() == thisParam;
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
+                                return isThisExpression( castExpr->get_arg(), thisParam );
+                        }
+                        return false;
+                }
+                /// returns a MemberExpr if expr is effectively just member access on the 'this' parameter, else nullptr
+                MemberExpr * isThisMemberExpr( Expression * expr, DeclarationWithType * thisParam ) {
+                        if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
+                                if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                        return memberExpr;
+                                }
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                return isThisMemberExpr( castExpr->get_arg(), thisParam );
+                        }
+                        return nullptr;
+                }
                 void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
 …
                                 Expression * firstParam = appExpr->get_args().front();
                                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) {
+                                if ( isThisExpression( firstParam, thisParam ) ) {
                                         // if calling another constructor on thisParam, assume that function handles
                                         // all members - if it doesn't a warning will appear in that function.
+                                        if ( varExpr->get_var() == thisParam ) {
+                                                unhandled.clear();
+                                        }
+                                } else {
+                                        // if first parameter is a member expression then
+                                        // remove the member from unhandled set.
+                                        handleFirstParam( firstParam );
+                                }
+                        }
+                        Parent::visit( appExpr );
+                }
+                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
+                        using namespace std;
+                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
+                                if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( addrExpr->get_arg() ) ) {
+                                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
+                                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
+                                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
+                                                                if ( varExpr->get_var() == thisParam ) {
+                                                                        unhandled.erase( memberExpr->get_member() );
+                                                                }
+                                                        }
+                                                }
+                                        unhandled.clear();
+                                } else if ( MemberExpr * memberExpr = isThisMemberExpr( firstParam, thisParam ) ) {
+                                        // if first parameter is a member expression on the this parameter,
+                                        // then remove the member from unhandled set.
+                                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                                unhandled.erase( memberExpr->get_member() );
+                                        }
+                                }
+                        }
+                        Parent::visit( appExpr );
+                }
 …
                         if ( ! isCtor ) return;
+                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
+                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
+                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
+                                                if ( varExpr->get_var() == thisParam ) {
+                                                        if ( unhandled.count( memberExpr->get_member() ) ) {
+                                                                // emit a warning because a member was used before it was constructed
+                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
+                                                        }
+                                                }
+                                        }
+                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                if ( unhandled.count( memberExpr->get_member() ) ) {
+                                        // emit a warning because a member was used before it was constructed
+                                        usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
+                                }
+                        }
 …
                         ctorExpr->set_callExpr( nullptr );
                         ctorExpr->set_env( nullptr );
+                        delete ctorExpr;
                         Expression *& firstArg = callExpr->get_args().front();
+                        UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                        assign->get_args().push_back( new VariableExpr( tmp ) );
+                        assign->get_args().push_back( firstArg );
+                        assign->set_result( ctorExpr->get_result()->clone() );
+                        firstArg = assign;
+                        CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) );
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        firstArg = new VariableExpr( tmp );
+                        // for constructor expr:
+                        //   T x;
+                        //   x{};
+                        // results in:
+                        //   T x;
+                        //   T & tmp;
+                        //   &tmp = &x, ?{}(tmp), tmp
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
-                        delete ctorExpr;
                         return commaExpr;
+                }

src/InitTweak/GenInit.cc

-              raf08051
+              r28e58fd
 #include <list>                    // for _List_iterator, list
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"    // for PassVisitor, WithGuards, WithShort...
 #include "Common/SemanticError.h"  // for SemanticError
 …
           protected:
                 FunctionType * ftype;
+                FunctionType * ftype = nullptr;
                 std::string funcName;
         };
 …
                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
+                // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && ! returnVals.front()->get_type()->get_lvalue() ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
+                        UntypedExpr *construct = new UntypedExpr( new NameExpr( "?{}" ) );
+                        construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
+                        construct->get_args().push_back( returnStmt->get_expr() );
+                        stmtsToAddBefore.push_back(new ExprStmt(noLabels, construct));
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
                         // return the retVal object
 …
         bool CtorDtor::isManaged( Type * type ) const {
+                // at least for now, references are never constructed
+                if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
                 ValueGuard< Type::Qualifiers > qualifiers( type->get_qualifiers() );
 …
         void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) {
+                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
                         std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
                         assert( ! params.empty() );
+                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
+                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
+                        Type * type = InitTweak::getPointerBase( params.front()->get_type() );
+                        assert( type );
+                        managedTypes.insert( SymTab::Mangler::mangle( type ) );
+                }
+        }

src/InitTweak/InitTweak.cc

-              raf08051
+              r28e58fd
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
                         increment->get_args().push_back( new AddressExpr( index->clone() ) );
+                        increment->get_args().push_back( index->clone() );
                         *out++ = new ExprStmt( noLabels, increment );
+                }
 …
                 template<typename CallExpr>
                 Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
                         if ( pos >= callExpr->get_args().size() ) assertf( false, "asking for argument that doesn't exist. Return NULL/throw exception?" );
+                        if ( pos >= callExpr->get_args().size() ) assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.", pos, toString( callExpr ).c_str() );
                         for ( Expression *& arg : callExpr->get_args() ) {
                                 if ( pos == 0 ) return arg;
 …
                 } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
                         return arrayType->get_base();
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
+                        return refType->get_base();
                 } else {
                         return NULL;
 …
                 if ( ftype->get_parameters().size() != 2 ) return 0;
                 Type * t1 = ftype->get_parameters().front()->get_type();
+                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                 Type * t2 = ftype->get_parameters().back()->get_type();
+                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                assert( ptrType );
+                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                assert( t1 );
+                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
                         return function;
                 } else {

src/InitTweak/InitTweak.h

-              raf08051
+              r28e58fd
 // helper functions for initialization
 namespace InitTweak {
-        bool isConstructor( const std::string & );
-        bool isDestructor( const std::string & );
-        bool isAssignment( const std::string & );
-        bool isCtorDtor( const std::string & );
-        bool isCtorDtorAssign( const std::string & );
         FunctionDecl * isAssignment( Declaration * decl );
         FunctionDecl * isDestructor( Declaration * decl );

src/MakeLibCfa.cc

-              raf08051
+              r28e58fd
 #include "MakeLibCfa.h"
 #include <cassert>                 // for assert
+#include <cassert>                  // for assert
 #include <string>                   // for operator==, string
 #include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup, Ope...
+#include "Common/PassVisitor.h"     // for PassVisitor
 #include "Common/SemanticError.h"   // for SemanticError
 #include "Common/UniqueName.h"      // for UniqueName
 …
 namespace LibCfa {
         class MakeLibCfa : public Visitor {
           public:
                 void visit( FunctionDecl* funcDecl );
                 void visit( ObjectDecl* objDecl );
+        namespace {
+                struct MakeLibCfa {
+                  public:
+                        void postvisit( FunctionDecl* funcDecl );
+                std::list< Declaration* > &get_newDecls() { return newDecls; }
+          private:
+                std::list< Declaration* > newDecls;
+        };
+                        std::list< Declaration* > newDecls;
+                };
+        }
         void makeLibCfa( std::list< Declaration* > &prelude ) {
                 MakeLibCfa maker;
+                PassVisitor<MakeLibCfa> maker;
                 acceptAll( prelude, maker );
                 prelude.splice( prelude.end(), maker.get_newDecls() );
+                prelude.splice( prelude.end(), maker.pass.newDecls );
+        }
+        void MakeLibCfa::visit( FunctionDecl* origFuncDecl ) {
+                if ( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+                if ( origFuncDecl->get_statements() ) return;
+        namespace {
+                struct TypeFinder       {
+                        void postvisit( TypeInstType * inst ) {
+                                // if a type variable is seen, assume all zero_t/one_t in the parameter list
+                                //  can be replaced with the equivalent 'general' pointer.
+                                if ( type ) return;
+                                if ( inst->isFtype ) {
+                                        type = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), false ) );
+                                } else {
+                                        type = new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) );
+                                }
+                        }
+                        Type * type = nullptr;
+                };
+                FunctionDecl *funcDecl = origFuncDecl->clone();
+                CodeGen::OperatorInfo opInfo;
+                bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
+                assert( lookResult );
+                assert( ! funcDecl->get_statements() );
+                UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) );
+                UniqueName paramNamer( "_p" );
+                std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin();
+                assert( param != funcDecl->get_functionType()->get_parameters().end() );
+                struct ZeroOneReplacer {
+                        ZeroOneReplacer( Type * t ) : type( t ) {}
+                        ~ZeroOneReplacer() { delete type; }
+                        Type * type = nullptr;
                 for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
                         if ( (*param)->get_name() == "" ) {
                                 (*param)->set_name( paramNamer.newName() );
                                 (*param)->set_linkage( LinkageSpec::C );
+                        Type * common( Type * t ) {
+                                if ( ! type ) return t;
+                                delete t;
+                                return type->clone();
+                        }
-                        newExpr->get_args().push_back( new VariableExpr( *param ) );
-                } // for
+                funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+                newDecls.push_back( funcDecl );
+                        Type * postmutate( OneType * t ) { return common( t ); }
+                        Type * postmutate( ZeroType * t ) { return common( t ); }
+                };
+                switch ( opInfo.type ) {
+                  case CodeGen::OT_INDEX:
+                  case CodeGen::OT_CALL:
+                  case CodeGen::OT_PREFIX:
+                  case CodeGen::OT_POSTFIX:
+                  case CodeGen::OT_INFIX:
+                  case CodeGen::OT_PREFIXASSIGN:
+                  case CodeGen::OT_POSTFIXASSIGN:
+                  case CodeGen::OT_INFIXASSIGN:
+                  case CodeGen::OT_CTOR:
+                  case CodeGen::OT_DTOR:
+                                funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+                                break;
+                  case CodeGen::OT_CONSTANT:
+                  case CodeGen::OT_LABELADDRESS:
+                        // there are no intrinsic definitions of 0/1 or label addresses as functions
+                        assert( false );
+                } // switch
+        }
+                void fixZeroOneType( FunctionDecl * origFuncDecl ) {
+                        // find appropriate type to replace zero_t/one_t with
+                        PassVisitor<TypeFinder> finder;
+                        origFuncDecl->type->accept( finder );
+                        // replace zero_t/one_t in function type
+                        PassVisitor<ZeroOneReplacer> replacer( finder.pass.type );
+                        origFuncDecl->type->acceptMutator( replacer );
+                }
+        void MakeLibCfa::visit( ObjectDecl* origObjDecl ) {
+                if ( origObjDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+                void MakeLibCfa::postvisit( FunctionDecl* origFuncDecl ) {
+                        // don't change non-intrinsic functions
+                        if ( origFuncDecl->get_linkage() != LinkageSpec::Intrinsic ) return;
+                        // replace zero_t/one_t with void */void (*)(void)
+                        fixZeroOneType( origFuncDecl );
+                        // skip functions already defined
+                        if ( origFuncDecl->get_statements() ) return;
+                ObjectDecl *objDecl = origObjDecl->clone();
+                assert( ! objDecl->get_init() );
+                std::list< Expression* > noDesignators;
+                objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), false ) ); // cannot be constructed
+                newDecls.push_back( objDecl );
+        }
+                        FunctionDecl *funcDecl = origFuncDecl->clone();
+                        CodeGen::OperatorInfo opInfo;
+                        bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
+                        assert( lookResult );
+                        assert( ! funcDecl->get_statements() );
+                        // build a recursive call - this is okay, as the call will actually be codegen'd using operator syntax
+                        UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) );
+                        UniqueName paramNamer( "_p" );
+                        std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin();
+                        assert( param != funcDecl->get_functionType()->get_parameters().end() );
+                        for ( ; param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
+                                // name each unnamed parameter
+                                if ( (*param)->get_name() == "" ) {
+                                        (*param)->set_name( paramNamer.newName() );
+                                        (*param)->set_linkage( LinkageSpec::C );
+                                }
+                                // add parameter to the expression
+                                newExpr->get_args().push_back( new VariableExpr( *param ) );
+                        } // for
+                        funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+                        newDecls.push_back( funcDecl );
+                        switch ( opInfo.type ) {
+                          case CodeGen::OT_INDEX:
+                          case CodeGen::OT_CALL:
+                          case CodeGen::OT_PREFIX:
+                          case CodeGen::OT_POSTFIX:
+                          case CodeGen::OT_INFIX:
+                          case CodeGen::OT_PREFIXASSIGN:
+                          case CodeGen::OT_POSTFIXASSIGN:
+                          case CodeGen::OT_INFIXASSIGN:
+                          case CodeGen::OT_CTOR:
+                          case CodeGen::OT_DTOR:
+                                // return the recursive call
+                                        funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( std::list< Label >(), newExpr ) );
+                                        break;
+                          case CodeGen::OT_CONSTANT:
+                          case CodeGen::OT_LABELADDRESS:
+                                // there are no intrinsic definitions of 0/1 or label addresses as functions
+                                assert( false );
+                        } // switch
+                }
+        } // namespace
 } // namespace LibCfa

src/Makefile.in

-              raf08051
+              r28e58fd
         SynTree/driver_cfa_cpp-PointerType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT) \
+        SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT) \
 …
         SynTree/VoidType.cc SynTree/BasicType.cc \
         SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
+        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
 …
 SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT):  \
+        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-PointerType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceToType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Statement.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TupleExpr.Po@am__quote@
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ArrayType.obj `if test -f 'SynTree/ArrayType.cc'; then $(CYGPATH_W) 'SynTree/ArrayType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ArrayType.cc'; fi`
+SynTree/driver_cfa_cpp-ReferenceType.o: SynTree/ReferenceType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
+SynTree/driver_cfa_cpp-ReferenceType.obj: SynTree/ReferenceType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
 SynTree/driver_cfa_cpp-FunctionType.o: SynTree/FunctionType.cc

src/Parser/DeclarationNode.cc

-              raf08051
+              r28e58fd
 } // DeclarationNode::newTypeDecl
 DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Pointer );
+DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers, OperKinds kind ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
         if ( qualifiers ) {
                 return newnode->addQualifiers( qualifiers );
 …
 DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
+                assert( p->type->kind == TypeData::Pointer || TypeData::Reference );
                 setBase( p->type );
                 p->type = nullptr;
 …
 DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
+                assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference );
                 if ( type ) {
                         switch ( type->kind ) {

src/Parser/ExpressionNode.cc

-              raf08051
+              r28e58fd
 Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) );
+        args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_unary_ptr
 …
 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) );
+        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );

src/Parser/ParseNode.h

raf08051	r28e58fd
243	243	static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
244	244	static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
245		static DeclarationNode * newPointer( DeclarationNode * qualifiers );
	245	static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
246	246	static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
247	247	static DeclarationNode * newVarArray( DeclarationNode * qualifiers );

src/Parser/TypeData.cc

-              raf08051
+              r28e58fd
           case Unknown:
           case Pointer:
+          case Reference:
           case EnumConstant:
                 // nothing else to initialize
 …
           case Unknown:
           case Pointer:
+          case Reference:
           case EnumConstant:
                 // nothing to destroy
 …
           case EnumConstant:
           case Pointer:
+          case Reference:
                 // nothing else to copy
                 break;
 …
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
                         dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
 …
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
                         ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
                         // add assignment operator:  T * ?=?(T *, T)
                         FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
                         assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
 …
           case TypeData::Array:
                 return buildArray( td );
+          case TypeData::Reference:
+                return buildReference( td );
           case TypeData::Function:
                 return buildFunction( td );
 …
         buildForall( td->forall, at->get_forall() );
         return at;
+} // buildPointer
+} // buildArray
+ReferenceType * buildReference( const TypeData * td ) {
+        ReferenceType * rt;
+        if ( td->base ) {
+                rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) );
+        } else {
+                rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        } // if
+        buildForall( td->forall, rt->get_forall() );
+        return rt;
+} // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {

src/Parser/TypeData.h

-              raf08051
+              r28e58fd
 struct TypeData {
         enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
+        enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
                                 SymbolicInst, Tuple, Typeof, Builtin, Unknown };
 …
 PointerType * buildPointer( const TypeData * );
 ArrayType * buildArray( const TypeData * );
+ReferenceType * buildReference( const TypeData * );
 AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
 ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );

src/Parser/lex.ll

-              raf08051
+              r28e58fd
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Thu Jul 27 21:46:06 2017
  * Update Count     : 550
+ * Last Modified On : Tue Aug 22 22:43:39 2017
+ * Update Count     : 558
  */
 …
 #define NUMERIC_RETURN(x)       rm_underscore(); RETURN_VAL( x ) // numeric constant
 #define KEYWORD_RETURN(x)       RETURN_CHAR( x )                        // keyword
+#define QKEYWORD_RETURN(x)      typedefTable.isKind( yytext ); RETURN_VAL(x); // quasi-keyword
 #define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
 #define ATTRIBUTE_RETURN()      RETURN_VAL( ATTR_IDENTIFIER )
 …
 __label__               { KEYWORD_RETURN(LABEL); }                              // GCC
 long                    { KEYWORD_RETURN(LONG); }
-lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
 monitor                 { KEYWORD_RETURN(MONITOR); }                    // CFA
 mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
 …
 throw                   { KEYWORD_RETURN(THROW); }                              // CFA
 throwResume             { KEYWORD_RETURN(THROWRESUME); }                // CFA
+timeout                 { QKEYWORD_RETURN(TIMEOUT); }                   // CFA
 trait                   { KEYWORD_RETURN(TRAIT); }                              // CFA
 try                             { KEYWORD_RETURN(TRY); }                                // CFA
 …
 __volatile              { KEYWORD_RETURN(VOLATILE); }                   // GCC
 __volatile__    { KEYWORD_RETURN(VOLATILE); }                   // GCC
+waitfor                 { KEYWORD_RETURN(WAITFOR); }
+or                              { QKEYWORD_RETURN(WOR); }                               // CFA
+when                    { KEYWORD_RETURN(WHEN); }
 while                   { KEYWORD_RETURN(WHILE); }
 with                    { KEYWORD_RETURN(WITH); }                               // CFA

src/Parser/parser.yy

-              raf08051
+              r28e58fd
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Aug 20 09:21:54 2017
 // Update Count     : 2573
+// Last Modified On : Wed Aug 23 21:08:08 2017
+// Update Count     : 2704
 //
 …
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
 %token FORALL LVALUE MUTEX VIRTUAL                                              // CFA
+%token FORALL MUTEX VIRTUAL                                             // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
 …
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 %token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH // CFA
+%token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 %token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
 …
 // names and constants: lexer differentiates between identifier and typedef names
 %token<tok> IDENTIFIER                  QUOTED_IDENTIFIER               TYPEDEFname                             TYPEGENname
+%token<tok> TIMEOUT                             WOR
 %token<tok> ATTR_IDENTIFIER             ATTR_TYPEDEFname                ATTR_TYPEGENname
 %token<tok> INTEGERconstant             CHARACTERconstant               STRINGliteral
 …
 %type<tok> identifier  no_attr_identifier
 %type<tok> identifier_or_type_name  no_attr_identifier_or_type_name  attr_name
+%type<tok> quasi_keyword
 %type<constant> string_literal
 %type<str> string_literal_list
 …
 %type<sn> iteration_statement                   jump_statement
 %type<sn> with_statement                                exception_statement                     asm_statement
+%type<sn> when_clause_opt                               waitfor_statement                       waitfor_clause                          waitfor                         timeout
 %type<sn> fall_through_opt                              fall_through
 %type<sn> statement                                             statement_list
 …
 %type<sn> case_clause                                   case_value_list                         case_label                                      case_label_list
 %type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
 %type<sn> /* handler_list */                    handler_clause                          finally_clause
+%type<sn> handler_clause                                finally_clause
 %type<catch_kind> handler_key
 …
 // Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string
 // is ambiguous:
 // .---------.                          matches IF '(' comma_expression ')' statement
+// .---------.                          matches IF '(' comma_expression ')' statement . (reduce)
 // if ( C ) S1 else S2
+// `-----------------'          matches IF '(' comma_expression ')' statement ELSE statement */
+%nonassoc THEN  // rule precedence for IF '(' comma_expression ')' statement
+%nonassoc ELSE  // token precedence for start of else clause in IF statement
+// `-----------------'          matches IF '(' comma_expression ')' statement . (shift) ELSE statement */
+// Similar issues exit with the waitfor statement.
+// Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
+// associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
+%precedence THEN        // rule precedence for IF/WAITFOR statement
+%precedence WOR         // token precedence for start of WOR in WAITFOR statement
+%precedence TIMEOUT     // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
 %start translation_unit                                                                 // parse-tree root
 …
+        ;
+quasi_keyword:                                                                                  // CFA
+        TIMEOUT
+        | WOR
+        ;
 identifier:
         IDENTIFIER
         | ATTR_IDENTIFIER                                                                       // CFA
+        | quasi_keyword
+        ;
 no_attr_identifier:
         IDENTIFIER
+        | quasi_keyword
+        ;
 …
 primary_expression:
         IDENTIFIER                                                                                      // typedef name cannot be used as a variable name
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        | quasi_keyword
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | tuple
 …
         | '&'                                                                           { $$ = OperKinds::AddressOf; }
                 // GCC, address of label must be handled by semantic check for ref,ref,label
 //      | ANDAND                                                                        { $$ = OperKinds::And; }
+        | ANDAND                                                                        { $$ = OperKinds::And; }
+        ;
 …
         conditional_expression
         | unary_expression assignment_operator assignment_expression
                 { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+        ;
 …
         | jump_statement
         | with_statement
+        | waitfor_statement
         | exception_statement
         | asm_statement
 …
 with_statement:
+        WITH '(' tuple_expression_list ')' compound_statement
+                { $$ = (StatementNode *)0; }                                    // FIX ME
+        WITH '(' tuple_expression_list ')' statement
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
+when_clause_opt:
+        // empty
+                { $$ = nullptr; }                                                               // FIX ME
+        | WHEN '(' comma_expression ')'
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
+waitfor:
+        WAITFOR '(' identifier ')'
+                { $$ = nullptr; }                                                               // FIX ME
+        | WAITFOR '(' identifier ',' argument_expression_list ')'
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
+timeout:
+        TIMEOUT '(' comma_expression ')'
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
+waitfor_clause:
+        when_clause_opt waitfor statement %prec THEN
+                { $$ = nullptr; }                                                               // FIX ME
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = nullptr; }                                                               // FIX ME
+        | when_clause_opt timeout statement %prec THEN
+                { $$ = nullptr; }                                                               // FIX ME
+        | when_clause_opt ELSE statement
+                { $$ = nullptr; }                                                               // FIX ME
+        | when_clause_opt timeout statement WOR when_clause_opt ELSE statement
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
+waitfor_statement:
+        when_clause_opt waitfor statement %prec THEN
+                { $$ = nullptr; }                                                               // FIX ME
+        | when_clause_opt waitfor statement WOR waitfor_clause
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
 …
                 { $$ = new StatementNode( build_try( $2, $3, $4 ) ); }
+        ;
-//handler_list:
-//      handler_clause
-//              // ISO/IEC 9899:1999 Section 15.3(6 ) If present, a "..." handler shall be the last handler for its try block.
-//      | CATCH '(' ELLIPSIS ')' compound_statement
-//              { $$ = new StatementNode( build_catch( 0, $5, true ) ); }
-//      | handler_clause CATCH '(' ELLIPSIS ')' compound_statement
-//              { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( 0, $6, true ) ) ); }
-//      | CATCHRESUME '(' ELLIPSIS ')' compound_statement
-//              { $$ = new StatementNode( build_catch( 0, $5, true ) ); }
-//      | handler_clause CATCHRESUME '(' ELLIPSIS ')' compound_statement
-//              { $$ = (StatementNode *)$1->set_last( new StatementNode( build_catch( 0, $6, true ) ) ); }
-//      ;
 handler_clause:
 …
         | VOLATILE
                 { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
-        | LVALUE                                                                                        // CFA
-                { $$ = DeclarationNode::newTypeQualifier( Type::Lvalue ); }
         | MUTEX
                 { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); }
 …
 with_clause_opt:
         // empty
                 { $$ = (StatementNode *)0; }                                    // FIX ME
+                { $$ = nullptr; }                                                               // FIX ME
         | WITH '(' tuple_expression_list ')'
                 { $$ = (StatementNode *)0; }                                    // FIX ME
+                { $$ = nullptr; }                                                               // FIX ME
+        ;
 …
 attr_name:                                                                                              // GCC
         IDENTIFIER
+        | quasi_keyword
         | TYPEDEFname
         | TYPEGENname
 …
 variable_ptr:
         ptrref_operator variable_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' variable_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
 …
 function_ptr:
         ptrref_operator function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' function_ptr ')'
                 { $$ = $2; }
 …
 KR_function_ptr:
         ptrref_operator KR_function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list KR_function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' KR_function_ptr ')'
                 { $$ = $2; }
 …
 type_ptr:
         ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 identifier_parameter_ptr:
         ptrref_operator identifier_parameter_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' identifier_parameter_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 type_parameter_ptr:
         ptrref_operator type_parameter_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_parameter_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0 ); }
+                { $$ = DeclarationNode::newPointer( 0, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2 ); }
+                { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' abstract_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 abstract_parameter_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( nullptr ); }
+                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2 ); }
+                { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_parameter_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' abstract_parameter_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 variable_abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0 ); }
+                { $$ = DeclarationNode::newPointer( 0, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2 ); }
+                { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator variable_abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' variable_abstract_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
                 // No SUE declaration in parameter list.
         ptrref_operator type_specifier_nobody
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier_nobody
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
+        ;
 …
 cfa_abstract_ptr:                                                                               // CFA
         ptrref_operator type_specifier
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
+        ;

src/ResolvExpr/Alternative.cc

-              raf08051
+              r28e58fd
                 : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
+        Alternative::Alternative( const Alternative &other ) {
+                initialize( other, *this );
+        Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) {
+        }
         Alternative &Alternative::operator=( const Alternative &other ) {
                 if ( &other == this ) return *this;
+                initialize( other, *this );
+                delete expr;
+                cost = other.cost;
+                cvtCost = other.cvtCost;
+                expr = maybeClone( other.expr );
+                env = other.env;
                 return *this;
+        }
 …
                 other.expr = nullptr;
                 return *this;
+        }
-        void Alternative::initialize( const Alternative &src, Alternative &dest ) {
-                dest.cost = src.cost;
-                dest.cvtCost = src.cvtCost;
-                dest.expr = maybeClone( src.expr );
-                dest.env = src.env;
+        }

src/ResolvExpr/Alternative.h

raf08051	r28e58fd
39	39	~Alternative();
40	40
41		~~void initialize( const Alternative &src, Alternative &dest );~~
42
43	41	void print( std::ostream &os, int indent = 0 ) const;
44	42

src/ResolvExpr/AlternativeFinder.cc

-              raf08051
+              r28e58fd
         Cost sumCost( const AltList &in ) {
                 Cost total;
+                Cost total = Cost::zero;
                 for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
                         total += i->cost;
 …
                         expr->get_result()->accept( global_renamer );
+                }
+        }
+                void referenceToRvalueConversion( Expression *& expr ) {
+                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                                // cast away reference from expr
+                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        }
+                }
+        } // namespace
         template< typename InputIterator, typename OutputIterator >
 …
                         if ( alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
+                                stream << "Can't choose between " << alternatives.size() << " alternatives for expression ";
+                                AltList winners;
+                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
+                                stream << "Can't choose between " << winners.size() << " alternatives for expression ";
                                 expr->print( stream );
                                 stream << "Alternatives are:";
-                                AltList winners;
-                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
                                 printAlts( winners, stream, 8 );
                                 throw SemanticError( stream.str() );
 …
         void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
                 // adds anonymous member interpretations whenever an aggregate value type is seen.
+                Expression * expr = alt.expr->clone();
+                std::unique_ptr< Expression > manager( expr ); // RAII for expr
+                alt.env.apply( expr->get_result() );
+                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( expr->get_result() ) ) {
+                // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
+                std::unique_ptr<Expression> aggrExpr( alt.expr->clone() );
+                alt.env.apply( aggrExpr->get_result() );
+                Type * aggrType = aggrExpr->get_result();
+                if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
+                        aggrType = aggrType->stripReferences();
+                        aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                }
+                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
                         addAggMembers( structInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( expr->get_result() ) ) {
+                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
                         addAggMembers( unionInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
                 } // if
+        }
 …
         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
                 // by this point, member must be a name expr
+                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
+                NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
+                if ( ! nameExpr ) return;
                 const std::string & name = nameExpr->get_name();
                 std::list< Declaration* > members;
 …
                         // during parsing and reusing that information here.
                         std::stringstream ss( constantExpr->get_constant()->get_value() );
                         int val;
+                        int val = 0;
                         std::string tmp;
                         if ( ss >> val && ! (ss >> tmp) ) {
 …
                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
                 Cost convCost( 0, 0, 0 );
+                Cost convCost = Cost::zero;
                 std::list< DeclarationWithType* >& formals = function->get_parameters();
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
 …
                                 actualType->print( std::cerr, 8 );
+                        )
                         Cost actualCost;
+                        Cost actualCost = Cost::zero;
                         if ( formal == formals.end() ) {
                                 if ( function->get_isVarArgs() ) {
+                                        convCost += Cost( 1, 0, 0 );
+                                        convCost.incUnsafe();
+                                        // convert reference-typed expressions to value-typed expressions
+                                        referenceToRvalueConversion( *actualExpr );
                                         continue;
                                 } else {
 …
                                 std::cerr << std::endl << " to ";
                                 formalType->print( std::cerr, 8 );
+                                std::cerr << std::endl << "environment is: ";
+                                alt.env.print( std::cerr, 8 );
+                                std::cerr << std::endl;
+                        )
                         Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
 …
                         convCost += newCost;
                         actualCost += newCost;
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
+                        if ( actualCost != Cost::zero ) {
                                 Type *newType = formalType->clone();
                                 alt.env.apply( newType );
                                 *actualExpr = new CastExpr( *actualExpr, newType );
+                        }
                         convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ) );
                         ++formal; // can't be in for-loop update because of the continue
+                }
 …
+                        }
                         convCost += newCost;
                         convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ) );
+                }
 …
                         Expression * actual = actualIt->expr;
                         Type * actualType = actual->get_result();
                         PRINT(
                                 std::cerr << "formal type is ";
 …
+                        )
                         if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                // std::cerr << "unify failed" << std::endl;
                                 return false;
+                        }
 …
                         // match flattened actuals with formal parameters - actuals will be grouped to match
                         // with formals as appropriate
                         Cost cost;
+                        Cost cost = Cost::zero;
                         std::list< Expression * > newExprs;
                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
 …
                 AssertionSet newNeed;
                 //AssertionParentSet needParents;
+                PRINT(
+                        std::cerr << "env is: " << std::endl;
+                        newAlt.env.print( std::cerr, 0 );
+                        std::cerr << std::endl;
+                )
                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
 //      PRINT(
 …
                         makeExprList( instantiatedActuals, appExpr->get_args() );
                         PRINT(
+                                std::cerr << "instantiate function success: " << appExpr << std::endl;
                                 std::cerr << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cerr, 8 );
 …
                                 UntypedExpr *vexpr = untypedExpr->clone();
                                 vexpr->set_result( pt.clone() );
                                 alternatives.push_back( Alternative( vexpr, env, Cost()) );
+                                alternatives.push_back( Alternative( vexpr, env, Cost::zero) );
                                 return;
+                        }
 …
                 AltList candidates;
                 SemanticError errors;
                 for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
+                for ( AltList::iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
                         try {
                                 PRINT(
 …
+                                )
                                 // check if the type is pointer to function
+                                PointerType *pointer;
+                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
+                                if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->get_result()->stripReferences() ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                referenceToRvalueConversion( func->expr );
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                         // XXX
 …
                                                         makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                }
+                                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
+                                                EqvClass eqvClass;
+                                                if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                                } // for
+                                                        } // if
+                                        }
+                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
+                                        referenceToRvalueConversion( func->expr );
+                                        EqvClass eqvClass;
+                                        if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                        } // for
                                                 } // if
                                         } // if
 …
+                                        }
                                         for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
                                                 // check if the type is pointer to function
+                                                PointerType *pointer;
+                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
+                                                if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                                referenceToRvalueConversion( funcOp->expr );
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                                         AltList currentAlt;
 …
                                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
                                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
                                 std::cerr << "Case +++++++++++++" << std::endl;
+                                std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
                                 std::cerr << "formals are:" << std::endl;
                                 printAll( function->get_parameters(), std::cerr, 8 );
 …
         bool isLvalue( Expression *expr ) {
                 // xxx - recurse into tuples?
                 return expr->has_result() && expr->get_result()->get_lvalue();
+                return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+        }
 …
         Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                        if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
+                        // Argument expression is a tuple and the target type is not void and not a reference type.
+                        // Cast each member of the tuple to its corresponding target type, producing the tuple of those
+                        // cast expressions. If there are more components of the tuple than components in the target type,
+                        // then excess components do not come out in the result expression (but UniqueExprs ensure that
+                        // side effects will still be done).
+                        if ( Tuples::maybeImpureIgnoreUnique( argExpr ) ) {
                                 // expressions which may contain side effects require a single unique instance of the expression.
                                 argExpr = new UniqueExpr( argExpr );
 …
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
                         int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = i->expr->get_result()->size() - castExpr->get_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(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
                         Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unify( castExpr->get_result(), i->expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCost( i->expr->get_result(), castExpr->get_result(), indexer, i->env );
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
                                 thisCost += Cost( 0, 0, discardedValues );
+                                thisCost.incSafe( discardedValues );
                                 candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
 …
                 funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
+                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
+                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
+                                addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
+                        std::unique_ptr<Expression> aggrExpr( agg->expr->clone() );
+                        Type * aggrType = aggrExpr->get_result();
+                        if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
+                                aggrType = aggrType->stripReferences();
+                                aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                        }
+                        // find member of the given type
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
+                                addAggMembers( structInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
+                                addAggMembers( unionInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
+                                addTupleMembers( tupleType, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
                         } // if
                 } // for
 …
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
                         alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
 …
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
+                        referenceToRvalueConversion( choice.expr );
                         alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
 …
                         // return the lowest cost alternative for the argument
                         Alternative &choice = winners.front();
+                        referenceToRvalueConversion( choice.expr );
                         alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
                 } // if
 …
                         for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
                                 VariableExpr newExpr( *i );
                                 alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for
 …
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away
                                         thisCost += Cost( 0, 0, discardedValues );
+                                        thisCost.incSafe( discardedValues );
                                         candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                }

src/ResolvExpr/CastCost.cc

-              raf08051
+              r28e58fd
                                 assert( type );
                                 if ( type->get_base() ) {
                                         return castCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
                 } // if
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
                         return Cost( 0, 0, 0 );
+                        return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return Cost( 0, 0, 1 );
+                        return Cost::safe;
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         CastCost converter( dest, indexer, env );
 …
                         } else {
                                 // xxx - why are we adding cost 0 here?
                                 return converter.get_cost() + Cost( 0, 0, 0 );
+                                return converter.get_cost() + Cost::zero;
                         } // if
                 } // if
 …
                 if ( destAsPointer && basicType->isInteger() ) {
                         // necessary for, e.g. unsigned long => void*
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } else {
                         ConversionCost::visit( basicType );
+                        cost = conversionCost( basicType, dest, indexer, env );
                 } // if
+        }
 …
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
                                 cost = Cost( 0, 0, 1 );
+                                cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
 …
                                 int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
                                 if ( castResult > 0 ) {
                                         cost = Cost( 0, 0, 1 );
+                                        cost = Cost::safe;
                                 } else if ( castResult < 0 ) {
                                         cost = Cost::infinity;
 …
                         if ( destAsBasic->isInteger() ) {
                                 // necessary for, e.g. void* => unsigned long
                                 cost = Cost( 1, 0, 0 );
+                                cost = Cost::unsafe;
                         } // if
+                }

src/ResolvExpr/CommonType.cc

-              raf08051
+              r28e58fd
 #include "typeops.h"                     // for isFtype
+/// #define DEBUG
+// #define DEBUG
 namespace ResolvExpr {
 …
                 virtual void visit( PointerType *pointerType );
                 virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
                 virtual void visit( FunctionType *functionType );
                 virtual void visit( StructInstType *aggregateUseType );
 …
                 virtual void visit( OneType *oneType );
+                void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer );
+                template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer );
+                template< typename RefType > void handleRefType( RefType *inst, Type *other );
                 Type *result;
 …
         };
+        Type * handleReference( ReferenceType * refType, Type * other, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
+                Type * result = nullptr, * common = nullptr;
+                AssertionSet have, need;
+                OpenVarSet newOpen( openVars );
+                // need unify to bind type variables
+                if ( unify( refType->get_base(), other, env, have, need, newOpen, indexer, common ) ) {
+                        // std::cerr << "unify success" << std::endl;
+                        if ( widenSecond ) {
+                                // std::cerr << "widen second" << std::endl;
+                                if ( widenFirst || other->get_qualifiers() <= refType->get_qualifiers() ) {
+                                        result = new ReferenceType( refType->get_qualifiers(), common ); // refType->clone();
+                                        result->get_qualifiers() |= other->get_qualifiers();
+                                }
+                        } else if ( widenFirst ) {
+                                // std::cerr << "widen first" << std::endl;
+                                if ( widenSecond || refType->get_qualifiers() <= other->get_qualifiers() ) {
+                                        result = common;
+                                        result->get_qualifiers() |= refType->get_qualifiers();
+                                }
+                        }
+                } else {
+                        // std::cerr << "exact unify failed: " << refType << " " << other << std::endl;
+                }
+                // std::cerr << "common type of reference [" << refType << "] and non-reference [" << other << "] is [" << result << "]" << std::endl;
+                return result;
+        }
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
                 CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
+                int depth1 = type1->referenceDepth();
+                int depth2 = type2->referenceDepth();
+                if ( depth1 > 0 || depth2 > 0 ) {
+                        int diff = depth1-depth2;
+                        // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
+                        if ( diff > 1 || diff < -1 ) return nullptr;
+                        // special case where one type has a reference depth of 1 larger than the other
+                        if ( diff > 0 ) {
+                                return handleReference( safe_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
+                        } else if ( diff < 0 ) {
+                                return handleReference( safe_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
+                        }
+                        // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
+                }
                 type1->accept( visitor );
                 Type *result = visitor.get_result();
 …
                 } // if
 #ifdef DEBUG
                 std::cout << "============= commonType" << std::endl << "type1 is ";
                 type1->print( std::cout );
                 std::cout << " type2 is ";
                 type2->print( std::cout );
+                std::cerr << "============= commonType" << std::endl << "type1 is ";
+                type1->print( std::cerr );
+                std::cerr << " type2 is ";
+                type2->print( std::cerr );
                 if ( result ) {
                         std::cout << " common type is ";
                         result->print( std::cout );
+                        std::cerr << " common type is ";
+                        result->print( std::cerr );
                 } else {
                         std::cout << " no common type";
                 } // if
                 std::cout << std::endl;
+                        std::cerr << " no common type";
+                } // if
+                std::cerr << std::endl;
 #endif
                 return result;
 …
+        }
+        void CommonType::getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer ) {
+        template< typename Pointer >
+        void CommonType::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) {
                 if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) {
                         OpenVarSet::const_iterator entry = openVars.find( var->get_name() );
 …
         void CommonType::visit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
+                        // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
                         if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
                                 getCommonWithVoidPointer( otherPointer, pointerType );
 …
                         } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
                                            && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) {
+                                // std::cerr << "middle case" << std::endl;
                                 Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers();
                                 pointerType->get_base()->get_qualifiers() = Type::Qualifiers();
 …
                                 OpenVarSet newOpen( openVars );
                                 if ( unifyExact( pointerType->get_base(), otherPointer->get_base(), env, have, need, newOpen, indexer ) ) {
+                                        // std::cerr << "unifyExact success" << std::endl;
                                         if ( tq1 < tq2 ) {
                                                 result = pointerType->clone();
 …
                                         result->get_qualifiers() = tq1 | tq2;
                                 } else {
                                         /// std::cout << "place for ptr-to-type" << std::endl;
+                                        /// std::cerr << "place for ptr-to-type" << std::endl;
                                 } // if
                                 pointerType->get_base()->get_qualifiers() = tq1;
 …
         void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
+        void CommonType::visit( ReferenceType *refType ) {
+                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
+                        // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
+                        // std::cerr << ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) << (refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond) << std::endl;
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) {
+                                getCommonWithVoidPointer( otherRef, refType );
+                        } else if ( widenSecond && dynamic_cast< VoidType* >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) {
+                                getCommonWithVoidPointer( refType, otherRef );
+                        } else if ( ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst )
+                                           && ( refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond ) ) {
+                                // std::cerr << "middle case" << std::endl;
+                                Type::Qualifiers tq1 = refType->get_base()->get_qualifiers(), tq2 = otherRef->get_base()->get_qualifiers();
+                                refType->get_base()->get_qualifiers() = Type::Qualifiers();
+                                otherRef->get_base()->get_qualifiers() = Type::Qualifiers();
+                                AssertionSet have, need;
+                                OpenVarSet newOpen( openVars );
+                                if ( unifyExact( refType->get_base(), otherRef->get_base(), env, have, need, newOpen, indexer ) ) {
+                                        if ( tq1 < tq2 ) {
+                                                result = refType->clone();
+                                        } else {
+                                                result = otherRef->clone();
+                                        } // if
+                                        result->get_qualifiers() = tq1 | tq2;
+                                } else {
+                                        /// std::cerr << "place for ptr-to-type" << std::endl;
+                                } // if
+                                refType->get_base()->get_qualifiers() = tq1;
+                                otherRef->get_base()->get_qualifiers() = tq2;
+                        } // if
+                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
+                        result = refType->clone();
+                        result->get_qualifiers() |= type2->get_qualifiers();
+                } // if
+        }
         void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
         void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
 …
                 if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
                         Type * temp = type2;
+                        ValueGuard< Type * > temp( type2 );
                         type2 = enumInstType;
+                        temp->accept( *this );
+                        type2 = temp;
+                        temp.old->accept( *this );
                 } // if
+        }

src/ResolvExpr/ConversionCost.cc

-              raf08051
+              r28e58fd
 namespace ResolvExpr {
+        const Cost Cost::zero = Cost( 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1 );
+        const Cost Cost::zero = Cost( 0, 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1, -1 );
+        const Cost Cost::unsafe = Cost( 1, 0, 0, 0 );
+        const Cost Cost::poly = Cost( 0, 1, 0, 0 );
+        const Cost Cost::safe = Cost( 0, 0, 1, 0 );
+        const Cost Cost::reference = Cost( 0, 0, 0, 1 );
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
 …
                         EqvClass eqvClass;
                         NamedTypeDecl *namedType;
+///     std::cout << "type inst " << destAsTypeInst->get_name();
+                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
                                 if ( eqvClass.type ) {
 …
+                                }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+///       std::cout << " found" << std::endl;
+                                PRINT( std::cerr << " found" << std::endl; )
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                                 // all typedefs should be gone by this point
                                 assert( type );
                                 if ( type->get_base() ) {
                                         return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
+///     std::cout << " not found" << std::endl;
+                } // if
+///   std::cout << "src is ";
+///   src->print( std::cout );
+///   std::cout << std::endl << "dest is ";
+///   dest->print( std::cout );
+///   std::cout << std::endl << "env is" << std::endl;
+///   env.print( std::cout, 8 );
+                        PRINT( std::cerr << " not found" << std::endl; )
+                } // if
+                PRINT(
+                        std::cerr << "src is ";
+                        src->print( std::cerr );
+                        std::cerr << std::endl << "dest is ";
+                        dest->print( std::cerr );
+                        std::cerr << std::endl << "env is" << std::endl;
+                        env.print( std::cerr, 8 );
+                )
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
+///     std::cout << "compatible!" << std::endl;
                         return Cost( 0, 0, 0 );
+                        PRINT( std::cerr << "compatible!" << std::endl; )
+                        return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return Cost( 0, 0, 1 );
+                        return Cost::safe;
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         ConversionCost converter( dest, indexer, env );
 …
                                 return Cost::infinity;
                         } else {
+                                return converter.get_cost() + Cost( 0, 0, 0 );
+                        } // if
+                } // if
+                                return converter.get_cost() + Cost::zero;
+                        } // if
+                } // if
+        }
+        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                PRINT( std::cerr << "convert to reference cost..." << std::endl; )
+                if ( diff > 0 ) {
+                        // TODO: document this
+                        Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env );
+                        cost.incReference();
+                        return cost;
+                } else if ( diff < -1 ) {
+                        // TODO: document this
+                        Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env );
+                        cost.incReference();
+                        return cost;
+                } else if ( diff == 0 ) {
+                        ReferenceType * srcAsRef = dynamic_cast< ReferenceType * >( src );
+                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
+                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
+                                PRINT( std::cerr << "converting between references" << std::endl; )
+                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                        return Cost::safe;
+                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                                        int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env );
+                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
+                                        if ( assignResult < 0 ) {
+                                                return Cost::safe;
+                                        } else if ( assignResult > 0 ) {
+                                                return Cost::unsafe;
+                                        } // if
+                                } // if
+                        } else {
+                                PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
+                                ConversionCost converter( dest, indexer, env );
+                                src->accept( converter );
+                                return converter.get_cost();
+                        } // if
+                } else {
+                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
+                        assert( diff == -1 && destAsRef );
+                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
+                                if ( src->get_lvalue() ) {
+                                        PRINT(
+                                                std::cerr << "lvalue to reference conversion" << std::endl;
+                                                std::cerr << src << " => " << destAsRef << std::endl;
+                                        )
+                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
+                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::reference; // cost needs to be non-zero to add cast
+                                        } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
+                                        } else {
+                                                return Cost::unsafe;
+                                        } // if
+                                } else if ( destAsRef->get_base()->get_const() ) {
+                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
+                                        // rvalue-to-const-reference conversion: T => const T &
+                                        return Cost::safe;
+                                } else {
+                                        PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
+                                        // rvalue-to-reference conversion: T => T &
+                                        return Cost::unsafe;
+                                } // if
+                        } // if
+                        PRINT( std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl; )
+                }
+                return Cost::infinity;
+        }
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
+                return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env );
+        }
 …
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult );
                         } // if
                 } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
                         // xxx - not positive this is correct, but appears to allow casting int => enum
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
+        }
 …
         void ConversionCost::visit(PointerType *pointerType) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
+                        if ( pointerType->get_base()->get_qualifiers() <= destAsPtr->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                cost = Cost( 0, 0, 1 );
+                        } else {
+                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr; )
+                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
+                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
+                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                if ( tq1 == tq2 ) {
+                                        // types are the same
+                                        cost = Cost::zero;
+                                } else {
+                                        // types are the same, except otherPointer has more qualifiers
+                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
+                                        cost = Cost::safe;
+                                }
+                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
                                 int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
+                                if ( assignResult < 0 ) {
+                                        cost = Cost( 0, 0, 1 );
+                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
+                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
+                                        cost = Cost::safe;
                                 } else if ( assignResult > 0 ) {
                                         cost = Cost( 1, 0, 0 );
+                                        cost = Cost::unsafe;
                                 } // if
+                                // assignResult == 0 means Cost::Infinity
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
+        }
         void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
+        void ConversionCost::visit(ReferenceType *refType) {
+                // Note: dest can never be a reference, since it would have been caught in an earlier check
+                assert( ! dynamic_cast< ReferenceType * >( dest ) );
+                // convert reference to rvalue: cv T1 & => T2
+                // recursively compute conversion cost from T1 to T2.
+                // cv can be safely dropped because of 'implicit dereference' behavior.
+                refType->get_base()->accept( *this );
+                if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) {
+                        cost.incReference();  // prefer exact qualifiers
+                } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) {
+                        cost.incSafe(); // then gaining qualifiers
+                } else {
+                        cost.incUnsafe(); // lose qualifiers as last resort
+                }
+                PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
+        }
         void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 …
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
                 integer.accept( *this );
                 if ( cost < Cost( 1, 0, 0 ) ) {
+                integer.accept( *this );  // safe if dest >= int
+                if ( cost < Cost::unsafe ) {
                         cost.incSafe();
                 } // if
 …
                         assert( type );
                         if ( type->get_base() ) {
                                 cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost( 0, 0, 1 );
+                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
                         } // if
                 } // if
 …
         void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
                 Cost c;
+                Cost c = Cost::zero;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
                         std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
 …
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult + 1 );
+                        }
                 } else if ( dynamic_cast< PointerType* >( dest ) ) {
                         cost = Cost( 0, 0, 1 );
+                        cost = Cost::safe;
+                }
+        }
 …
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult + 1 );
+                        }
+                }

src/ResolvExpr/ConversionCost.h

-              raf08051
+              r28e58fd
                 virtual void visit(PointerType *pointerType);
                 virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
                 virtual void visit(FunctionType *functionType);
                 virtual void visit(StructInstType *aggregateUseType);
 …
                 const TypeEnvironment &env;
         };
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env );
 } // namespace ResolvExpr

src/ResolvExpr/Cost.h

-              raf08051
+              r28e58fd
 // file "LICENCE" distributed with Cforall.
 //
 // Cost.h --
+// Cost.h --
 //
 // Author           : Richard C. Bilson
 …
 namespace ResolvExpr {
         class Cost {
+          private:
+                Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost );
           public:
+                Cost();
+                Cost( int unsafe, int poly, int safe );
+                void incUnsafe( int inc = 1 );
+                void incPoly( int inc = 1 );
+                void incSafe( int inc = 1 );
+                Cost & incUnsafe( int inc = 1 );
+                Cost & incPoly( int inc = 1 );
+                Cost & incSafe( int inc = 1 );
+                Cost & incReference( int inc = 1 );
                 Cost operator+( const Cost &other ) const;
                 Cost operator-( const Cost &other ) const;
 …
                 bool operator!=( const Cost &other ) const;
                 friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
                 static const Cost zero;
                 static const Cost infinity;
+                static const Cost unsafe;
+                static const Cost poly;
+                static const Cost safe;
+                static const Cost reference;
           private:
                 int compare( const Cost &other ) const;
+                int unsafe;
+                int poly;
+                int safe;
+                int unsafeCost;
+                int polyCost;
+                int safeCost;
+                int referenceCost;
         };
         inline Cost::Cost() : unsafe( 0 ), poly( 0 ), safe( 0 ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), referenceCost( referenceCost ) {}
         inline Cost::Cost( int unsafe, int poly, int safe ) : unsafe( unsafe ), poly( poly ), safe( safe ) {}
         inline void Cost::incUnsafe( int inc ) {
                 unsafe += inc;
+        inline Cost & Cost::incUnsafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                unsafeCost += inc;
+                return *this;
+        }
+        inline void Cost::incPoly( int inc ) {
+                poly += inc;
+        inline Cost & Cost::incPoly( int inc ) {
+                if ( *this == infinity ) return *this;
+                polyCost += inc;
+                return *this;
+        }
+        inline void Cost::incSafe( int inc ) {
+                safe += inc;
+        inline Cost & Cost::incSafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                safeCost += inc;
+                return *this;
+        }
+        inline Cost & Cost::incReference( int inc ) {
+                if ( *this == infinity ) return *this;
+                referenceCost += inc;
+                return *this;
+        }
         inline Cost Cost::operator+( const Cost &other ) const {
+                return Cost( unsafe + other.unsafe, poly + other.poly, safe + other.safe );
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, referenceCost + other.referenceCost );
+        }
         inline Cost Cost::operator-( const Cost &other ) const {
+                return Cost( unsafe - other.unsafe, poly - other.poly, safe - other.safe );
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, referenceCost - other.referenceCost );
+        }
         inline Cost &Cost::operator+=( const Cost &other ) {
+                unsafe += other.unsafe;
+                poly += other.poly;
+                safe += other.safe;
+                if ( *this == infinity ) return *this;
+                if ( other == infinity ) {
+                        *this = infinity;
+                        return *this;
+                }
+                unsafeCost += other.unsafeCost;
+                polyCost += other.polyCost;
+                safeCost += other.safeCost;
+                referenceCost += other.referenceCost;
                 return *this;
+        }
         inline bool Cost::operator<( const Cost &other ) const {
+            if ( *this == infinity ) return false;
+            if ( other == infinity ) return true;
+            if ( unsafe > other.unsafe ) {
+                if ( *this == infinity ) return false;
+                if ( other == infinity ) return true;
+                if ( unsafeCost > other.unsafeCost ) {
                         return false;
             } else if ( unsafe < other.unsafe ) {
+                } else if ( unsafeCost < other.unsafeCost ) {
                         return true;
             } else if ( poly > other.poly ) {
+                } else if ( polyCost > other.polyCost ) {
                         return false;
             } else if ( poly < other.poly ) {
+                } else if ( polyCost < other.polyCost ) {
                         return true;
             } else if ( safe > other.safe ) {
+                } else if ( safeCost > other.safeCost ) {
                         return false;
             } else if ( safe < other.safe ) {
+                } else if ( safeCost < other.safeCost ) {
                         return true;
             } else {
+                } else if ( referenceCost > other.referenceCost ) {
                         return false;
+            } // if
+                } else if ( referenceCost < other.referenceCost ) {
+                        return true;
+                } else {
+                        return false;
+                } // if
+        }
         inline bool Cost::operator==( const Cost &other ) const {
+                return unsafe == other.unsafe
+                        && poly == other.poly
+                        && safe == other.safe;
+                return unsafeCost == other.unsafeCost
+                        && polyCost == other.polyCost
+                        && safeCost == other.safeCost
+                        && referenceCost == other.referenceCost;
+        }
 …
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
                 os << "( " << cost.unsafe << ", " << cost.poly << ", " << cost.safe << " )";
+                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << ", " << cost.referenceCost << " )";
                 return os;
+        }

src/ResolvExpr/PtrsAssignable.cc

-              raf08051
+              r28e58fd
 // file "LICENCE" distributed with Cforall.
 //
 // PtrsAssignable.cc --
+// PtrsAssignable.cc --
 //
 // Author           : Richard C. Bilson
 …
         void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
         void PtrsAssignable::visit( EnumInstType *inst ) {
                 if ( dynamic_cast< EnumInstType* >( inst ) ) {
+        void PtrsAssignable::visit( EnumInstType * ) {
+                if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
                 } else if ( BasicType *bt = dynamic_cast< BasicType* >( inst ) ) {
+                } else if ( BasicType *bt = dynamic_cast< BasicType* >( dest ) ) {
                         result = bt->get_kind() == BasicType::SignedInt;
+                }
 …
         void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
         void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
 } // namespace ResolvExpr

src/ResolvExpr/ResolveTypeof.cc

-              raf08051
+              r28e58fd
                         assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
                         Type *newType = newExpr->get_result();
+                        newExpr->set_result( nullptr );
                         delete typeofType;
+                        delete newExpr;
                         return newType;
                 } // if

src/ResolvExpr/Unify.cc

-              raf08051
+              r28e58fd
                 virtual void visit(PointerType *pointerType);
                 virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
                 virtual void visit(FunctionType *functionType);
                 virtual void visit(StructInstType *aggregateUseType);
 …
         bool bindVar( TypeInstType *typeInst, Type *other, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
+                // remove references from other, so that type variables can only bind to value types
+                other = other->stripReferences();
                 OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
                 assert( tyvar != openVars.end() );
 …
                                 } // if
                         } else {
+                                common = type1->clone();
+                                common->get_qualifiers() = tq1 | tq2;
                                 result = true;
                         } // if
 …
                         markAssertions( haveAssertions, needAssertions, pointerType );
                         markAssertions( haveAssertions, needAssertions, otherPointer );
+                } // if
+        }
+        void Unify::visit(ReferenceType *refType) {
+                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
+                        result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        markAssertions( haveAssertions, needAssertions, refType );
+                        markAssertions( haveAssertions, needAssertions, otherRef );
                 } // if
+        }

src/ResolvExpr/typeops.h

-              raf08051
+              r28e58fd
         Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-        template< typename SrcIterator, typename DestIterator >
-        Cost castCostList( SrcIterator srcBegin, SrcIterator srcEnd, DestIterator destBegin, DestIterator destEnd, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                Cost ret;
-                if ( destBegin == destEnd ) {
-                        if ( srcBegin == srcEnd ) {
-                                return Cost::zero;
-                        } else {
-                                return Cost( 0, 0, 1 );
-                        } // if
-                } // if
-                while ( srcBegin != srcEnd && destBegin != destEnd ) {
-                        Cost thisCost = castCost( *srcBegin++, *destBegin++, indexer, env );
-                        if ( thisCost == Cost::infinity ) {
-                                return Cost::infinity;
-                        } // if
-                        ret += thisCost;
-                } // while
-                if ( srcBegin == srcEnd && destBegin == destEnd ) {
-                        return ret;
-                } else {
-                        return Cost::infinity;
-                } // if
+        }
         // in ConversionCost.cc
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-        template< typename SrcIterator, typename DestIterator >
-        Cost conversionCostList( SrcIterator srcBegin, SrcIterator srcEnd, DestIterator destBegin, DestIterator destEnd, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                Cost ret;
-                while ( srcBegin != srcEnd && destBegin != destEnd ) {
-                        Cost thisCost = conversionCost( *srcBegin++, *destBegin++, indexer, env );
-                        if ( thisCost == Cost::infinity ) {
-                                return Cost::infinity;
-                        } // if
-                        ret += thisCost;
-                } // while
-                if ( srcBegin == srcEnd && destBegin == destEnd ) {
-                        return ret;
-                } else {
-                        return Cost::infinity;
-                } // if
+        }
         // in PtrsAssignable.cc

src/SymTab/Autogen.cc

-              raf08051
+              r28e58fd
 // Update Count     : 62
 //
 #include "Autogen.h"
 …
 #include <vector>                  // for vector
+#include "AddVisit.h"             // for addVisit
+#include "Common/ScopedMap.h"     // for ScopedMap
+#include "GenPoly/DeclMutator.h"  // for DeclMutator
+#include "GenPoly/ScopedSet.h"    // for ScopedSet
+#include "Parser/LinkageSpec.h"   // for AutoGen, Intrinsic, Spec
+#include "SymTab/Mangler.h"       // for mangleType
+#include "SynTree/Statement.h"    // for SwitchStmt (ptr only), CompoundStmt
+#include "SynTree/Type.h"         // for Type, ArrayType, Type::StorageClasses
+#include "SynTree/Visitor.h"      // for Visitor
+#include "AddVisit.h"              // for addVisit
+#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
+#include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
+#include "Common/utility.h"        // for cloneAll, operator+
+#include "GenPoly/DeclMutator.h"   // for DeclMutator
+#include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
+#include "SymTab/Mangler.h"        // for Mangler
+#include "SynTree/Attribute.h"     // For Attribute
+#include "SynTree/Mutator.h"       // for maybeMutate
+#include "SynTree/Statement.h"     // for CompoundStmt, ReturnStmt, ExprStmt
+#include "SynTree/Type.h"          // for FunctionType, Type, TypeInstType
+#include "SynTree/Visitor.h"       // for maybeAccept, Visitor, acceptAll
+class Attribute;
 namespace SymTab {
 …
         FunctionType * genDefaultType( Type * paramType ) {
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->get_parameters().push_back( dstParam );
 …
                 ftype->get_returnVals().push_back( returnVal );
                 return ftype;
+        }
-        /// true if the aggregate's layout is dynamic
-        template< typename AggrDecl >
-        bool hasDynamicLayout( AggrDecl * aggregateDecl ) {
-                for ( TypeDecl * param : aggregateDecl->get_parameters() ) {
-                        if ( param->isComplete() ) return true;
+                }
-                return false;
+        }
 …
                         FunctionType * ftype = funcDecl->get_functionType();
                         assert( ! ftype->get_parameters().empty() );
+                        Type * t = safe_dynamic_cast< PointerType * >( ftype->get_parameters().front()->get_type() )->get_base();
+                        Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() );
+                        assert( t );
                         map.insert( Mangler::mangleType( t ), true );
+                }
 …
                         FunctionType * ftype = data.genType( refType );
                         if(concurrent_type && InitTweak::isDestructor( data.fname )) {
+                        if(concurrent_type && CodeGen::isDestructor( data.fname )) {
                                 ftype->get_parameters().front()->get_type()->set_mutex( true );
+                        }
 …
                 FunctionType *copyCtorType = genCopyType( refType->clone() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
                 // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
                 // right now these cases work, but that might change.
 …
         /// generates a single struct member operation (constructor call, destructor call, assignment call)
+        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) {
+                ObjectDecl * returnVal = NULL;
+                if ( ! func->get_functionType()->get_returnVals().empty() ) {
+                        returnVal = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_returnVals().front() );
+                }
+        void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward = true ) {
                 InitTweak::InitExpander srcParam( src );
+                // assign to destination (and return value if generic)
+                UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) );
+                Expression *dstselect = new MemberExpr( field, derefExpr );
+                // assign to destination
+                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
                 genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
-                if ( isDynamicLayout && returnVal ) {
-                        // xxx - there used to be a dereference on returnVal, but this seems to have been wrong?
-                        Expression *retselect = new MemberExpr( field, new VariableExpr( returnVal ) );
-                        genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
-                } // if
+        }
         /// generates the body of a struct function by iterating the struct members (via parameters) - generates default ctor, copy ctor, assignment, and dtor bodies, but NOT field ctor bodies
         template<typename Iterator>
         void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) {
+        void makeStructFunctionBody( Iterator member, Iterator end, FunctionDecl * func, bool forward = true ) {
                 for ( ; member != end; ++member ) {
                         if ( DeclarationWithType *field = dynamic_cast< DeclarationWithType * >( *member ) ) { // otherwise some form of type declaration, e.g. Aggregate
 …
                                 Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
                                 makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout, forward );
+                                makeStructMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
                 } // for
 …
         /// void ?{}(A *, int) and void?{}(A *, int, int) for a struct A which has two int fields.
         template<typename Iterator>
         void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func, bool isDynamicLayout ) {
+        void makeStructFieldCtorBody( Iterator member, Iterator end, FunctionDecl * func ) {
                 FunctionType * ftype = func->get_functionType();
                 std::list<DeclarationWithType*> & params = ftype->get_parameters();
 …
                                         // matching parameter, initialize field with copy ctor
                                         Expression *srcselect = new VariableExpr(*parameter);
                                         makeStructMemberOp( dstParam, srcselect, field, func, isDynamicLayout );
+                                        makeStructMemberOp( dstParam, srcselect, field, func );
                                         ++parameter;
                                 } else {
                                         // no matching parameter, initialize field with default ctor
                                         makeStructMemberOp( dstParam, NULL, field, func, isDynamicLayout );
+                                        makeStructMemberOp( dstParam, NULL, field, func );
+                                }
+                        }
 …
                 // Make function polymorphic in same parameters as generic struct, if applicable
                 const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
-                bool isDynamicLayout = hasDynamicLayout( aggregateDecl );  // NOTE this flag is an incredibly ugly kludge; we should fix the assignment signature instead (ditto for union)
                 // generate each of the functions based on the supplied FuncData objects
 …
                 // field ctors are only generated if default constructor and copy constructor are both generated
                 unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } );
+                unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } );
                 if ( functionNesting == 0 ) {
 …
                         // generate appropriate calls to member ctor, assignment
                         // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
                         if ( ! InitTweak::isDestructor( dcl->get_name() ) ) {
                                 makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl, isDynamicLayout );
+                        if ( ! CodeGen::isDestructor( dcl->get_name() ) ) {
+                                makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl );
                         } else {
                                 makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, isDynamicLayout, false );
+                        }
                         if ( InitTweak::isAssignment( dcl->get_name() ) ) {
+                                makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, false );
+                        }
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
                                 // assignment needs to return a value
                                 FunctionType * assignType = dcl->get_functionType();
 …
                                         // our inheritance model. I think the correct way to handle this is to
                                         // cast the structure to the type of the member and let the resolver
+                                        // figure out whether it's valid and have a pass afterwards that fixes
+                                        // the assignment to use pointer arithmetic with the offset of the
+                                        // member, much like how generic type members are handled.
+                                        // figure out whether it's valid/choose the correct unnamed member
                                         continue;
+                                }
                                 memCtorType->get_parameters().push_back( new ObjectDecl( member->get_name(), Type::StorageClasses(), LinkageSpec::Cforall, 0, member->get_type()->clone(), 0 ) );
                                 FunctionDecl * ctor = genFunc( "?{}", memCtorType->clone(), functionNesting );
                                 makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor, isDynamicLayout );
+                                makeStructFieldCtorBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), ctor );
                                 declsToAdd.push_back( ctor );
+                        }
 …
         void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
                 UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
                 copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
                 copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
 …
                 ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
                 ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
-                ObjectDecl * returnVal = nullptr;
-                if ( ! ftype->get_returnVals().empty() ) {
-                        returnVal = safe_dynamic_cast< ObjectDecl * >( ftype->get_returnVals().front() );
+                }
                 makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
+                if ( returnVal ) {
+                if ( CodeGen::isAssignment( funcDecl->get_name() ) ) {
+                        // also generate return statement in assignment
                         funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                }
 …
                 cloneAll( typeParams, copyCtorType->get_forall() );
                 cloneAll( typeParams, assignType->get_forall() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units

src/SymTab/Autogen.h

-              raf08051
+              r28e58fd
         extern Type * SizeType;
+        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
+        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
+        extern FunctionDecl * dereferenceOperator;
+        // temporary
+        FunctionType * genAssignType( Type * paramType );
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
 …
         template< typename OutputIterator >
         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
         // want to be able to generate assignment, ctor, and dtor generically,
         // so fname is either ?=?, ?{}, or ^?{}
         UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+                // want to be able to generate assignment, ctor, and dtor generically,
+                // so fname is either ?=?, ?{}, or ^?{}
+                UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+        // do something special for unnamed members
+        dstParam = new AddressExpr( dstParam );
+        if ( addCast ) {
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+        }
+        fExpr->get_args().push_back( dstParam );
+                if ( addCast ) {
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed
+                        // and destructed with the same functions as non-qualified objects.
+                        // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                        // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                        // remove lvalue as a qualifier, this can change to
+                        //   type->get_qualifiers() = Type::Qualifiers();
+                        assert( type );
+                        Type * castType = type->clone();
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        // castType->set_lvalue( true ); // xxx - might not need this
+                        dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
+                }
+                fExpr->get_args().push_back( dstParam );
         Statement * listInit = srcParam.buildListInit( fExpr );
+                Statement * listInit = srcParam.buildListInit( fExpr );
         std::list< Expression * > args = *++srcParam;
         fExpr->get_args().splice( fExpr->get_args().end(), args );
+                std::list< Expression * > args = *++srcParam;
+                fExpr->get_args().splice( fExpr->get_args().end(), args );
         *out++ = new ExprStmt( noLabels, fExpr );
+                *out++ = new ExprStmt( noLabels, fExpr );
         srcParam.clearArrayIndices();
+                srcParam.clearArrayIndices();
         return listInit;
+                return listInit;
+        }
 …
                 UntypedExpr *inc = new UntypedExpr( update );
                 inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                inc->get_args().push_back( new VariableExpr( index ) );
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );

src/SymTab/Indexer.cc

-              raf08051
+              r28e58fd
 #include <utility>                 // for pair, make_pair, move
+#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
 …
         void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
                 // only need to perform this step for constructors, destructors, and assignment functions
                 if ( ! InitTweak::isCtorDtorAssign( id ) ) return;
+                if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
                 // helpful data structure
 …
                                 decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
                                 existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
                                 existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) );
+                                existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) );
                                 existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor);
                                 existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
 …
                                 assert( ! params.empty() );
                                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                                Type * base = safe_dynamic_cast< PointerType * >( params.front()->get_type() )->get_base();
+                                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                                assert( base );
                                 funcMap[ Mangler::mangle( base ) ] += function;
                         } else {

src/SymTab/Mangler.cc

-              raf08051
+              r28e58fd
                 mangleName << "A0";
                 maybeAccept( arrayType->get_base(), *this );
+        }
+        void Mangler::visit( ReferenceType *refType ) {
+                printQualifiers( refType );
+                mangleName << "R";
+                maybeAccept( refType->get_base(), *this );
+        }
 …
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {
 //                      mangleName << "R";
+//                      mangleName << "E";
 //              } // if
                 if ( type->get_lvalue() ) {

src/SymTab/Mangler.h

raf08051	r28e58fd
42	42	virtual void visit( PointerType *pointerType );
43	43	virtual void visit( ArrayType *arrayType );
	44	virtual void visit( ReferenceType *refType );
44	45	virtual void visit( FunctionType *functionType );
45	46	virtual void visit( StructInstType *aggregateUseType );

src/SymTab/Validate.cc

-              raf08051
+              r28e58fd
 #include "CodeGen/CodeGenerator.h"     // for genName
+#include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
 …
         };
+        FunctionDecl * dereferenceOperator = nullptr;
+        struct FindSpecialDeclarations final {
+                void previsit( FunctionDecl * funcDecl );
+        };
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 PassVisitor<EnumAndPointerDecay> epc;
 …
                 PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
+                PassVisitor<FindSpecialDeclarations> finder;
                 EliminateTypedef::eliminateTypedef( translationUnit );
 …
                 acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
+                acceptAll( translationUnit, finder );
+        }
 …
                 std::list< DeclarationWithType * > &params = funcType->get_parameters();
                 if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) {
+                if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
                                 throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
+                        }
                         PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() );
                         if ( ! ptrType || ptrType->is_array() ) {
                                 throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
+                        ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
+                        if ( ! refType ) {
+                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl );
+                        }
                         if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
+                        if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
                                 throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                        }
 …
+                }
+        }
+        void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) {
+                if ( ! dereferenceOperator ) {
+                        if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) {
+                                FunctionType * ftype = funcDecl->get_functionType();
+                                if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) {
+                                        dereferenceOperator = funcDecl;
+                                }
+                        }
+                }
+        }
 } // namespace SymTab

src/SynTree/AddressExpr.cc

-              raf08051
+              r28e58fd
 #include "Type.h"            // for PointerType, Type, Type::Qualifiers
+// Address expressions are typed based on the following inference rules:
+//    E : lvalue T  &..& (n references)
+//   &E :        T *&..& (n references)
+//
+//    E : T  &..&        (m references)
+//   &E : T *&..&        (m-1 references)
+//
+// That is, lvalues becomes
+namespace {
+        Type * addrType( Type * type ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
+                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+                } else {
+                        return new PointerType( Type::Qualifiers(), type->clone() );
+                }
+        }
+}
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
         if ( arg->has_result() ) {
+                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
+                if ( arg->get_result()->get_lvalue() ) {
+                        // lvalue, retains all layers of reference and gains a pointer inside the references
+                        set_result( addrType( arg->get_result() ) );
+                } else {
+                        // taking address of non-lvalue -- must be a reference, loses one layer of reference
+                        ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() );
+                        set_result( addrType( refType->get_base() ) );
+                }
+                // result of & is never an lvalue
+                get_result()->set_lvalue( false );
+        }
+}

src/SynTree/ApplicationExpr.cc

raf08051	r28e58fd
49	49	}
50	50
51		ApplicationExpr::ApplicationExpr( Expression funcExpr, const std::list< ~~Expression > & argList ) : function( funcExpr ), args( argList~~ ) {
	51	ApplicationExpr::ApplicationExpr( Expression funcExpr, const std::list<Expression > & args ) : function( funcExpr ), args( args ) {
52	52	PointerType pointer = safe_dynamic_cast< PointerType >( funcExpr->get_result() );
53	53	FunctionType function = safe_dynamic_cast< FunctionType >( pointer->get_base() );

src/SynTree/Declaration.h

-              raf08051
+              r28e58fd
         virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
         virtual Type *get_type() const = 0;
+        virtual Type * get_type() const = 0;
         virtual void set_type(Type *) = 0;
 …
         virtual ~ObjectDecl();
         virtual Type *get_type() const { return type; }
+        virtual Type * get_type() const { return type; }
         virtual void set_type(Type *newType) { type = newType; }
 …
         virtual ~FunctionDecl();
         Type *get_type() const;
+        Type * get_type() const;
         virtual void set_type(Type *);
         FunctionType *get_functionType() const { return type; }
+        FunctionType * get_functionType() const { return type; }
         void set_functionType( FunctionType *newValue ) { type = newValue; }
         CompoundStmt *get_statements() const { return statements; }

src/SynTree/Expression.cc

-              raf08051
+              r28e58fd
 #include "TypeSubstitution.h"        // for TypeSubstitution
+#include "GenPoly/Lvalue.h"
 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
 …
+}
+VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
+        VariableExpr * funcExpr = new VariableExpr( func );
+        funcExpr->set_result( new PointerType( Type::Qualifiers(), funcExpr->get_result() ) );
+        return funcExpr;
+}
 void VariableExpr::print( std::ostream &os, int indent ) const {
         os << "Variable Expression: ";
 …
 void AlignofExpr::print( std::ostream &os, int indent) const {
         os << std::string( indent, ' ' ) << "Alignof Expression on: ";
+        os << "Alignof Expression on: ";
         if (isType)
 …
 void AttrExpr::print( std::ostream &os, int indent) const {
         os << std::string( indent, ' ' ) << "Attr ";
+        os << "Attr ";
         attr->print( os, indent + 2 );
         if ( isType || expr ) {
 …
 namespace {
         TypeSubstitution makeSub( Type * t ) {
+                if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) {
+                        return makeSub( refType->get_base() );
+                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
                         return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
 …
         if ( Type * type = expr->get_result() ) {
                 Type * base = InitTweak::getPointerBase( type );
+                if ( ! base ) {
+                        std::cerr << type << std::endl;
+                assertf( base, "expected pointer type in dereference (type was %s)", toString( type ).c_str() );
+                ret->set_result( base->clone() );
+                if ( GenPoly::referencesPermissable() ) {
+                        // if references are still allowed in the AST, dereference returns a reference
+                        ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
+                } else {
+                        // references have been removed, in which case dereference returns an lvalue of the base type.
+                        ret->get_result()->set_lvalue( true );
+                }
-                assertf( base, "expected pointer type in dereference\n" );
-                ret->set_result( maybeClone( base ) );
+        }
         return ret;
 …
 void LogicalExpr::print( std::ostream &os, int indent )const {
         os << std::string( indent, ' ' ) << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+        os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
         arg1->print(os);
         os << " and ";
 …
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : initializer( initializer ) {
         assert( type && initializer );
+        type->set_lvalue( true );
         set_result( type );
+}

src/SynTree/Expression.h

raf08051	r28e58fd
284	284	void set_var( DeclarationWithType * newValue ) { var = newValue; }
285	285
	286	static VariableExpr * functionPointer( FunctionDecl * decl );
	287
286	288	virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
287	289	virtual void accept( Visitor & v ) { v.visit( this ); }

src/SynTree/Mutator.cc

-              raf08051
+              r28e58fd
+}
+Type *Mutator::mutate( ReferenceType *refType ) {
+        mutateAll( refType->get_forall(), *this );
+        refType->set_base( maybeMutate( refType->get_base(), *this ) );
+        return refType;
+}
 Type *Mutator::mutate( FunctionType *functionType ) {
         mutateAll( functionType->get_forall(), *this );

src/SynTree/Mutator.h

raf08051	r28e58fd
92	92	virtual Type* mutate( PointerType *pointerType );
93	93	virtual Type* mutate( ArrayType *arrayType );
	94	virtual Type* mutate( ReferenceType *refType );
94	95	virtual Type* mutate( FunctionType *functionType );
95	96	virtual Type* mutate( StructInstType *aggregateUseType );

src/SynTree/SynTree.h

raf08051	r28e58fd
101	101	class PointerType;
102	102	class ArrayType;
	103	class ReferenceType;
103	104	class FunctionType;
104	105	class ReferenceToType;

src/SynTree/TupleExpr.cc

-              raf08051
+              r28e58fd
         assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
+        get_result()->set_lvalue( type->get_lvalue() );
+        // like MemberExpr, TupleIndexExpr is always an lvalue
+        get_result()->set_lvalue( true );
+}

src/SynTree/Type.cc

-              raf08051
+              r28e58fd
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 Type *Type::stripDeclarator() {
+Type * Type::stripDeclarator() {
         Type * type = this;
         while ( Type * at = InitTweak::getPointerBase( type ) ) {
 …
         return type;
+}
+Type * Type::stripReferences() {
+        Type * type = this;
+        while ( ReferenceType * ref = dynamic_cast<ReferenceType *>( type ) ) {
+                type = ref->get_base();
+        }
+        return type;
+}
+int Type::referenceDepth() const { return 0; }
 void Type::print( std::ostream &os, int indent ) const {

src/SynTree/Type.h

-              raf08051
+              r28e58fd
         /// return type without outer pointers and arrays
+        Type *stripDeclarator();
+        Type * stripDeclarator();
+        /// return type without outer references
+        Type * stripReferences();
+        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
+        virtual int referenceDepth() const;
         virtual bool isComplete() const { return true; }
 …
         bool is_array() const { return isStatic || isVarLen || dimension; }
+        virtual bool isComplete() const { return ! isVarLen; }
         virtual PointerType *clone() const { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
 …
 };
+class ReferenceType : public Type {
+public:
+        Type *base;
+        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ReferenceType( const ReferenceType & );
+        virtual ~ReferenceType();
+        Type *get_base() { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+        virtual int referenceDepth() const;
+        // Since reference types act like value types, their size is the size of the base.
+        // This makes it simple to cast the empty tuple to a reference type, since casts that increase
+        // the number of values are disallowed.
+        virtual unsigned size() const { return base->size(); }
+        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
 class FunctionType : public Type {
   public:

src/SynTree/TypeExpr.cc

raf08051	r28e58fd
5	5	// file "LICENCE" distributed with Cforall.
6	6	//
7		// TypeExpr.cc --
	7	// TypeExpr.cc --
8	8	//
9	9	// Author : Richard C. Bilson

src/SynTree/TypeSubstitution.h

raf08051	r28e58fd
117	117	} // if
118	118	} else {
119		throw SemanticError( ~~"Attempt to provide non-type parameter for type parameter"~~, formal );
	119	throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal );
120	120	} // if
121	121	} else {

src/SynTree/Visitor.cc

-              raf08051
+              r28e58fd
 void Visitor::visit( PointerType *pointerType ) {
         acceptAll( pointerType->get_forall(), *this );
+        // xxx - should PointerType visit/mutate dimension?
         maybeAccept( pointerType->get_base(), *this );
+}
 …
         maybeAccept( arrayType->get_dimension(), *this );
         maybeAccept( arrayType->get_base(), *this );
+}
+void Visitor::visit( ReferenceType *refType ) {
+        acceptAll( refType->get_forall(), *this );
+        maybeAccept( refType->get_base(), *this );
+}

src/SynTree/Visitor.h

raf08051	r28e58fd
94	94	virtual void visit( PointerType *pointerType );
95	95	virtual void visit( ArrayType *arrayType );
	96	virtual void visit( ReferenceType *refType );
96	97	virtual void visit( FunctionType *functionType );
97	98	virtual void visit( StructInstType *aggregateUseType );

src/SynTree/module.mk

raf08051	r28e58fd
20	20	SynTree/PointerType.cc \
21	21	SynTree/ArrayType.cc \
	22	SynTree/ReferenceType.cc \
22	23	SynTree/FunctionType.cc \
23	24	SynTree/ReferenceToType.cc \

src/Tuples/Explode.cc

-              raf08051
+              r28e58fd
 #include "Explode.h"
+#include <list>                  // for list
+#include <list>               // for list
+#include "SynTree/Mutator.h"  // for Mutator
+#include "SynTree/Mutator.h"     // for Mutator
+#include "Common/PassVisitor.h"  // for PassVisitor
 namespace Tuples {
         namespace {
+                struct AddrExploder : public Mutator {
+                // remove one level of reference from a reference type -- may be useful elsewhere.
+                Type * getReferenceBase( Type * t ) {
+                        if ( ReferenceType * refType = dynamic_cast<ReferenceType *>( t ) ) {
+                                return refType->get_base();
+                        } else {
+                                // for the moment, I want to know immediately if a non-reference type is ever passed in here.
+                                assertf( false, "getReferenceBase for non-ref: %s", toString( refType ).c_str() );
+                                return nullptr;
+                        }
+                }
+                struct CastExploder {
+                        bool castAdded = false;
                         bool foundUniqueExpr = false;
                         Expression * applyAddr( Expression * expr, bool first = true ) {
+                        Expression * applyCast( Expression * expr, bool first = true ) {
                                 if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ){
                                         foundUniqueExpr = true;
                                         std::list< Expression * > exprs;
                                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
                                                 // move & into tuple exprs
                                                 exprs.push_back( applyAddr( expr, false ) );
+                                                // move cast into tuple exprs
+                                                exprs.push_back( applyCast( expr, false ) );
+                                        }
                                         // want the top-level expression to be address-taken, but not nested
+                                        // want the top-level expression to be cast to reference type, but not nested
                                         // tuple expressions
                                         if ( first ) {
+                                                return new AddressExpr( new TupleExpr( exprs ) );
+                                                castAdded = true;
+                                                Expression * tupleExpr = new TupleExpr( exprs );
+                                                return new CastExpr( tupleExpr, new ReferenceType( Type::Qualifiers(), tupleExpr->result->clone() ) );
                                         } else {
                                                 return new TupleExpr( exprs );
+                                        }
+                                }
+                                // anything else should be address-taken as normal
+                                return new AddressExpr( expr->clone() );
+                                if ( dynamic_cast<ReferenceType*>( expr->result ) ) {
+                                        // don't need to cast reference type to another reference type
+                                        return expr->clone();
+                                } else {
+                                        // anything else should be cast to reference as normal
+                                        castAdded = true;
+                                        return new CastExpr( expr->clone(), new ReferenceType( Type::Qualifiers(), expr->result->clone() ) );
+                                }
+                        }
                         virtual Expression * mutate( UniqueExpr * uniqueExpr ) {
                                 // move & into unique expr so that the unique expr has type T* rather than
+                        Expression * postmutate( UniqueExpr * uniqueExpr ) {
+                                // move cast into unique expr so that the unique expr has type T& rather than
                                 // type T. In particular, this transformation helps with generating the
                                 // correct code for address-taken member tuple expressions, since the result
                                 // should now be a tuple of addresses rather than the address of a tuple.
+                                // correct code for reference-cast member tuple expressions, since the result
+                                // should now be a tuple of references rather than a reference to a tuple.
                                 // Still, this code is a bit awkward, and could use some improvement.
+                                if ( dynamic_cast< AddressExpr * > ( uniqueExpr->get_expr() ) ) {
+                                        // this unique expression has already been mutated or otherwise shouldn't be (can't take the address-of an address-of expression)
+                                        return uniqueExpr;
+                                UniqueExpr * newUniqueExpr = new UniqueExpr( applyCast( uniqueExpr->get_expr() ), uniqueExpr->get_id() );
+                                delete uniqueExpr;
+                                if ( castAdded ) {
+                                        // if a cast was added by applyCast, then unique expr now has one more layer of reference
+                                        // than it had coming into this function. To ensure types still match correctly, need to cast
+                                        //  to reference base so that outer expressions are still correct.
+                                        castAdded = false;
+                                        Type * toType = getReferenceBase( newUniqueExpr->result );
+                                        return new CastExpr( newUniqueExpr, toType->clone() );
+                                }
+                                UniqueExpr * newUniqueExpr = new UniqueExpr( applyAddr( uniqueExpr->get_expr() ), uniqueExpr->get_id() );
+                                delete uniqueExpr;
+                                UntypedExpr * deref = UntypedExpr::createDeref( Mutator::mutate( newUniqueExpr ) );
+                                return deref;
+                                return newUniqueExpr;
+                        }
+                        virtual Expression * mutate( TupleIndexExpr * tupleExpr ) {
+                        Expression * postmutate( TupleIndexExpr * tupleExpr ) {
                                 // tuple index expr needs to be rebuilt to ensure that the type of the
                                 // field is consistent with the type of the tuple expr, since the field
                                 // may have changed from type T to T*.
                                 Expression * expr = tupleExpr->get_tuple()->acceptMutator( *this );
+                                // may have changed from type T to T&.
+                                Expression * expr = tupleExpr->get_tuple();
                                 tupleExpr->set_tuple( nullptr );
                                 TupleIndexExpr * ret = new TupleIndexExpr( expr, tupleExpr->get_index() );
 …
         } // namespace
+        Expression * distributeAddr( Expression * expr ) {
+                AddrExploder addrExploder;
+                expr = expr->acceptMutator( addrExploder );
+                if ( ! addrExploder.foundUniqueExpr ) {
+                        expr = new AddressExpr( expr );
+        Expression * distributeReference( Expression * expr ) {
+                PassVisitor<CastExploder> exploder;
+                expr = expr->acceptMutator( exploder );
+                if ( ! exploder.pass.foundUniqueExpr ) {
+                        // if a UniqueExpr was found, then the cast has already been added inside the UniqueExpr as appropriate
+                        expr = new CastExpr( expr, new ReferenceType( Type::Qualifiers(), expr->result->clone() ) );
+                }
                 return expr;

src/Tuples/Explode.h

-              raf08051
+              r28e58fd
 namespace Tuples {
+        /// helper function used by explode to properly distribute
+        /// '&' across a tuple expression
+        Expression * distributeAddr( Expression * expr );
+        Expression * distributeReference( Expression * );
         /// helper function used by explode
 …
         void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
                 if ( isTupleAssign ) {
                         // tuple assignment needs AddressExprs to be recursively exploded to easily get at all of the components
                         if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                        // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                                 ResolvExpr::AltList alts;
                                 explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
                                 for ( ResolvExpr::Alternative & alt : alts ) {
                                         // distribute '&' over all components
                                         alt.expr = distributeAddr( alt.expr );
+                                        // distribute reference cast over all components
+                                        alt.expr = distributeReference( alt.expr );
                                         *out++ = alt;
+                                }
 …
+                        }
+                }
                 Type * res = expr->get_result();
+                Type * res = expr->get_result()->stripReferences();
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
                         if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
 …
+                                }
                         } else {
+                                // tuple type, but not tuple expr - recursively index into its components
+                                // tuple type, but not tuple expr - recursively index into its components.
+                                // if expr type is reference, convert to value type
                                 Expression * arg = expr->clone();
                                 if ( Tuples::maybeImpure( arg ) && ! dynamic_cast< UniqueExpr * >( arg ) ) {
+                                if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
                                         // expressions which may contain side effects require a single unique instance of the expression.
                                         arg = new UniqueExpr( arg );
+                                }
+                                // cast reference to value type to facilitate further explosion
+                                if ( dynamic_cast<ReferenceType *>( arg->get_result() ) ) {
+                                        arg = new CastExpr( arg, tupleType->clone() );
+                                }
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {

src/Tuples/TupleAssignment.cc

-              raf08051
+              r28e58fd
 #include <string>                          // for string
+#include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"             // for UniqueName
 #include "Common/utility.h"                // for zipWith
 …
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
                 return dynamic_cast< TupleType * >( expr->get_result() );
+                return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
+        }
 …
+        }
+        bool pointsToTuple( Expression *expr ) {
+        bool refToTuple( Expression *expr ) {
+                assert( expr->get_result() );
                 // also check for function returning tuple of reference types
                 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                         return pointsToTuple( castExpr->get_arg() );
                 } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) {
                         return isTuple( addr->get_arg() );
+                        return refToTuple( castExpr->get_arg() );
+                } else {
+                        return isTuple( expr );
+                }
                 return false;
 …
         void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
                         if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
+                        if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
                                 fname = op->get_name();
                                 for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
                                         if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
                                         if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
+                                        if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) {
                                                 // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
                                                 continue;
 …
                                         const ResolvExpr::Alternative & alt1 = ali->front();
                                         auto begin = std::next(ali->begin(), 1), end = ali->end();
                                         if ( pointsToTuple(alt1.expr) ) {
+                                        if ( refToTuple(alt1.expr) ) {
                                                 if ( isMultAssign( begin, end ) ) {
                                                         matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
 …
                 ResolvExpr::Alternative lhsAlt = alts.front();
+                // peel off the cast that exists on ctor/dtor expressions
+                bool isCast = false;
+                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
+                        lhsAlt.expr = castExpr->get_arg();
+                        castExpr->set_arg( nullptr );
+                        delete castExpr;
+                        isCast = true;
+                // explode is aware of casts - ensure every LHS expression is sent into explode with a reference cast
+                if ( ! dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
+                        lhsAlt.expr = new CastExpr( lhsAlt.expr, new ReferenceType( Type::Qualifiers(), lhsAlt.expr->get_result()->clone() ) );
+                }
 …
                 explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs), true );
+                // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
+                if ( isCast ) {
+                        for ( ResolvExpr::Alternative & alt : lhs ) {
+                                Expression *& expr = alt.expr;
+                                Type * castType = expr->get_result()->clone();
+                                Type * type = InitTweak::getPointerBase( castType );
+                                assert( type );
+                                type->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                                type->set_lvalue( true ); // xxx - might not need this
+                                expr = new CastExpr( expr, castType );
+                for ( ResolvExpr::Alternative & alt : lhs ) {
+                        // every LHS value must be a reference - some come in with a cast expression, if it doesn't just cast to reference here.
+                        if ( ! dynamic_cast< ReferenceType * >( alt.expr->get_result() ) ) {
+                                alt.expr = new CastExpr( alt.expr, new ReferenceType( Type::Qualifiers(), alt.expr->get_result()->clone() ) );
+                        }
+                }
 …
                 assert( left );
                 std::list< Expression * > args;
                 args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) );
+                args.push_back( new VariableExpr( left ) );
                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
                 if ( right ) args.push_back( new VariableExpr( right ) );
 …
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
+                ret->set_init( ctorInit );
+                ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
+                EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                ctorInit->accept( rm );
+                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
+                if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                        ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
+                        ret->set_init( ctorInit );
+                        ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
+                        EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                        ctorInit->accept( rm );
+                }
                 return ret;
+        }

src/Tuples/TupleExpansion.cc

-              raf08051
+              r28e58fd
 namespace Tuples {
         namespace {
+                class MemberTupleExpander final : public Mutator {
+                public:
+                struct MemberTupleExpander final : public Mutator {
                         typedef Mutator Parent;
                         using Parent::mutate;
 …
                 };
+                class UniqueExprExpander final : public GenPoly::DeclMutator {
+                public:
+                        typedef GenPoly::DeclMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                struct UniqueExprExpander final : public WithDeclsToAdd {
+                        Expression * postmutate( UniqueExpr * unqExpr );
                         std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
 …
                 };
+                class TupleAssignExpander : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( TupleAssignExpr * tupleExpr );
+                struct TupleAssignExpander {
+                        Expression * postmutate( TupleAssignExpr * tupleExpr );
                 };
 …
                 };
+                class TupleIndexExpander {
+                public:
+                struct TupleIndexExpander {
                         Expression * postmutate( TupleIndexExpr * tupleExpr );
                 };
+                class TupleExprExpander final : public Mutator {
+                public:
+                        typedef Mutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( TupleExpr * tupleExpr ) override;
+                struct TupleExprExpander final {
+                        Expression * postmutate( TupleExpr * tupleExpr );
                 };
+        }
 …
         void expandUniqueExpr( std::list< Declaration * > & translationUnit ) {
                 UniqueExprExpander unqExpander;
                 unqExpander.mutateDeclarationList( translationUnit );
+                PassVisitor<UniqueExprExpander> unqExpander;
+                mutateAll( translationUnit, unqExpander );
+        }
         void expandTuples( std::list< Declaration * > & translationUnit ) {
                 TupleAssignExpander assnExpander;
+                PassVisitor<TupleAssignExpander> assnExpander;
                 mutateAll( translationUnit, assnExpander );
 …
                 mutateAll( translationUnit, idxExpander );
                 TupleExprExpander exprExpander;
+                PassVisitor<TupleExprExpander> exprExpander;
                 mutateAll( translationUnit, exprExpander );
+        }
 …
                         // 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::maybeImpure( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
+                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
                         aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
 …
+        }
+        Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
+                unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
+        Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) {
                 const int id = unqExpr->get_id();
 …
                         if ( unqExpr->get_object() ) {
                                 // an object was generated to represent this unique expression -- it should be added to the list of declarations now
                                 addDeclaration( unqExpr->get_object() );
+                                declsToAddBefore.push_back( unqExpr->get_object() );
                                 unqExpr->set_object( nullptr );
                                 // steal the expr from the unqExpr
 …
                         ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
                                                                                                         new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
                         addDeclaration( finished );
+                        declsToAddBefore.push_back( finished );
                         // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
                         // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
 …
+        }
+        Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
+                assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) );
+        Expression * TupleAssignExpander::postmutate( TupleAssignExpr * assnExpr ) {
                 StmtExpr * ret = assnExpr->get_stmtExpr();
                 assnExpr->set_stmtExpr( nullptr );
 …
                 for ( auto p : group_iterate( tupleType->get_types(), decl->get_parameters() ) ) {
                         Type * t = std::get<0>(p);
-                        TypeDecl * td = std::get<1>(p);
                         newType->get_parameters().push_back( new TypeExpr( t->clone() ) );
-                        if ( env ) {
-                                // add bindings to the type environment.
-                                // xxx - This may not be sufficient, it may be necessary to rename type variables on StructInstType?
-                                env->add( td->get_name(), t->clone() );
+                        }
+                }
                 delete tupleType;
 …
+        }
+        Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
+                // recursively expand sub-tuple-expressions
+                tupleExpr = safe_dynamic_cast<TupleExpr *>(Parent::mutate(tupleExpr));
+        Expression * TupleExprExpander::postmutate( TupleExpr * tupleExpr ) {
                 Type * result = tupleExpr->get_result();
                 std::list< Expression * > exprs = tupleExpr->get_exprs();
 …
                 class ImpurityDetector : public Visitor {
                 public:
+                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
                         typedef Visitor Parent;
                         virtual void visit( ApplicationExpr * appExpr ) {
 …
                                 maybeImpure = true;
+                        }
+                        virtual void visit( __attribute__((unused)) UntypedExpr * untypedExpr ) { maybeImpure = true; }
+                        virtual void visit( UntypedExpr * ) { maybeImpure = true; }
+                        virtual void visit( UniqueExpr * unq ) {
+                                if ( ignoreUnique ) {
+                                        // bottom out at unique expression.
+                                        // The existence of a unique expression doesn't change the purity of an expression.
+                                        // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
+                                        return;
+                                }
+                                maybeAccept( unq->expr, *this );
+                        }
                         bool maybeImpure = false;
+                        bool ignoreUnique;
                 };
         } // namespace
         bool maybeImpure( Expression * expr ) {
+                ImpurityDetector detector;
+                ImpurityDetector detector( false );
+                expr->accept( detector );
+                return detector.maybeImpure;
+        }
+        bool maybeImpureIgnoreUnique( Expression * expr ) {
+                ImpurityDetector detector( true );
                 expr->accept( detector );
                 return detector.maybeImpure;

src/Tuples/Tuples.h

-              raf08051
+              r28e58fd
         /// returns true if the expression may contain side-effects.
         bool maybeImpure( Expression * expr );
+        /// returns true if the expression may contain side-effect, ignoring the presence of unique expressions.
+        bool maybeImpureIgnoreUnique( Expression * expr );
 } // namespace Tuples

src/benchmark/csv-data.c

-              raf08051
+              r28e58fd
 coroutine GreatSuspender {};
 void ?{}( GreatSuspender * this ) {
+void ?{}( GreatSuspender & this ) {
         prime(this);
+}
 void main( GreatSuspender * this )
+void main( GreatSuspender & this )
+{
         while( true ) {
 …
 void resumer( GreatSuspender * this, const unsigned int NoOfTimes ) {
         for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
                 resume( this );
+                resume( *this );
+        }
+}
 …
 // single monitor entry
 monitor mon_t {};
 void dummy( mon_t * mutex m ) {}
+void dummy( mon_t & mutex m ) {}
 long long int measure_1_monitor_entry() {
 …
         StartTime = Time();
         for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
                 dummy( &mon );
+                dummy( mon );
+        }
         EndTime = Time();
 …
 //-----------------------------------------------------------------------------
 // multi monitor entry
 void dummy( mon_t * mutex m1,  mon_t * mutex m2 ) {}
+void dummy( mon_t & mutex m1,  mon_t & mutex m2 ) {}
 long long int measure_2_monitor_entry() {
 …
         StartTime = Time();
         for ( volatile unsigned int i = 0; i < NoOfTimes; i += 1 ) {
                 dummy( &mon1, &mon2 );
+                dummy( mon1, mon2 );
+        }
         EndTime = Time();
 …
 thread thrd1b {};
 void ?{}( thrd1a * this, long long int * out ) {
         this->out = out;
+}
 void side1A( mon_t * mutex a, long long int * out ) {
+void ?{}( thrd1a & this, long long int * out ) {
+        this.out = out;
+}
+void side1A( mon_t & mutex a, long long int * out ) {
         long long int StartTime, EndTime;
 …
+}
 void side1B( mon_t * mutex a ) {
+void side1B( mon_t & mutex a ) {
         for( int i = 0;; i++ ) {
                 signal(&cond1b);
 …
+}
 void main( thrd1a * this ) { side1A( &mon1, this->out ); }
 void main( thrd1b * this ) { side1B( &mon1 ); }
+void main( thrd1a & this ) { side1A( mon1, this.out ); }
+void main( thrd1b & this ) { side1B( mon1 ); }
 long long int measure_1_sched_int() {
 …
 thread thrd2b {};
 void ?{}( thrd2a * this, long long int * out ) {
         this->out = out;
+}
 void side2A( mon_t * mutex a, mon_t * mutex b, long long int * out ) {
+void ?{}( thrd2a & this, long long int * out ) {
+        this.out = out;
+}
+void side2A( mon_t & mutex a, mon_t & mutex b, long long int * out ) {
         long long int StartTime, EndTime;
 …
+}
 void side2B( mon_t * mutex a, mon_t * mutex b ) {
+void side2B( mon_t & mutex a, mon_t & mutex b ) {
         for( int i = 0;; i++ ) {
                 signal(&cond2b);
 …
+}
 void main( thrd2a * this ) { side2A( &mon1, &mon2, this->out ); }
 void main( thrd2b * this ) { side2B( &mon1, &mon2 ); }
+void main( thrd2a & this ) { side2A( mon1, mon2, this.out ); }
+void main( thrd2b & this ) { side2B( mon1, mon2 ); }
 long long int measure_2_sched_int() {

src/libcfa/Makefile.am

raf08051	r28e58fd
36	36	${AM_V_GEN}@BACKEND_CC@ @CFA_FLAGS@ -D__CFA_DEBUG__ -O0 -c -o $@ $<
37	37
38		EXTRA_FLAGS = -g -Wall -W~~error -W~~no-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
	38	EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
39	39
40	40	AM_CCASFLAGS = @CFA_FLAGS@

src/libcfa/Makefile.in

raf08051	r28e58fd
416	416	ARFLAGS = cr
417	417	lib_LIBRARIES = $(am__append_1) $(am__append_2)
418		EXTRA_FLAGS = -g -Wall -W~~error -W~~no-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
	418	EXTRA_FLAGS = -g -Wall -Wno-unused-function -imacros libcfa-prelude.c @CFA_FLAGS@
419	419	AM_CCASFLAGS = @CFA_FLAGS@
420	420	headers = fstream iostream iterator limits rational stdlib \

src/libcfa/concurrency/alarm.c

-              raf08051
+              r28e58fd
 __cfa_time_t zero_time = { 0 };
 void ?{}( __cfa_time_t * this ) { this->val = 0; }
 void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
 void ?{}( itimerval * this, __cfa_time_t * alarm ) {
         this->it_value.tv_sec = alarm->val / one_second;                        // seconds
         this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
         this->it_interval.tv_sec = 0;
         this->it_interval.tv_usec = 0;
+}
 void ?{}( __cfa_time_t * this, timespec * curr ) {
+void ?{}( __cfa_time_t & this ) { this.val = 0; }
+void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
+void ?{}( itimerval & this, __cfa_time_t * alarm ) {
+        this.it_value.tv_sec = alarm->val / one_second;                 // seconds
+        this.it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
+        this.it_interval.tv_sec = 0;
+        this.it_interval.tv_usec = 0;
+}
+void ?{}( __cfa_time_t & this, timespec * curr ) {
         uint64_t secs  = curr->tv_sec;
         uint64_t nsecs = curr->tv_nsec;
         this->val = (secs * one_second) + nsecs;
+}
 __cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
         this->val = 0;
         return *this;
+        this.val = (secs * one_second) + nsecs;
+}
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) {
+        this.val = 0;
+        return this;
+}
 …
 //=============================================================================================
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
         this->thrd = thrd;
         this->alarm = alarm;
         this->period = period;
         this->next = 0;
         this->set = false;
         this->kernel_alarm = false;
+}
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
         this->proc = proc;
         this->alarm = alarm;
         this->period = period;
         this->next = 0;
         this->set = false;
         this->kernel_alarm = true;
+}
 void ^?{}( alarm_node_t * this ) {
         if( this->set ) {
                 unregister_self( this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+        this.thrd = thrd;
+        this.alarm = alarm;
+        this.period = period;
+        this.next = 0;
+        this.set = false;
+        this.kernel_alarm = false;
+}
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+        this.proc = proc;
+        this.alarm = alarm;
+        this.period = period;
+        this.next = 0;
+        this.set = false;
+        this.kernel_alarm = true;
+}
+void ^?{}( alarm_node_t & this ) {
+        if( this.set ) {
+                unregister_self( &this );
+        }
+}

src/libcfa/concurrency/alarm.h

-              raf08051
+              r28e58fd
 // ctors
 void ?{}( __cfa_time_t * this );
 void ?{}( __cfa_time_t * this, zero_t zero );
 void ?{}( __cfa_time_t * this, timespec * curr );
 void ?{}( itimerval * this, __cfa_time_t * alarm );
+void ?{}( __cfa_time_t & this );
+void ?{}( __cfa_time_t & this, zero_t zero );
+void ?{}( __cfa_time_t & this, timespec * curr );
+void ?{}( itimerval & this, __cfa_time_t * alarm );
 __cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs );
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs );
 // logical ops
 …
 typedef alarm_node_t ** __alarm_it_t;
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ^?{}( alarm_node_t * this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ^?{}( alarm_node_t & this );
 struct alarm_list_t {
 …
 };
 static inline void ?{}( alarm_list_t * this ) {
         this->head = 0;
         this->tail = &this->head;
+static inline void ?{}( alarm_list_t & this ) {
+        this.head = 0;
+        this.tail = &this.head;
+}

src/libcfa/concurrency/coroutine

-              raf08051
+              r28e58fd
 // Anything that is resumed is a coroutine.
 trait is_coroutine(dtype T) {
       void main(T * this);
       coroutine_desc * get_coroutine(T * this);
+      void main(T & this);
+      coroutine_desc * get_coroutine(T & this);
 };
 #define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 //-----------------------------------------------------------------------------
 // Ctors and dtors
 void ?{}(coStack_t * this);
 void ?{}(coroutine_desc * this);
 void ?{}(coroutine_desc * this, const char * name);
 void ^?{}(coStack_t * this);
 void ^?{}(coroutine_desc * this);
+void ?{}(coStack_t & this);
+void ?{}(coroutine_desc & this);
+void ?{}(coroutine_desc & this, const char * name);
+void ^?{}(coStack_t & this);
+void ^?{}(coroutine_desc & this);
 //-----------------------------------------------------------------------------
 …
 forall(dtype T | is_coroutine(T))
 static inline void resume(T * cor);
+static inline void resume(T & cor);
 forall(dtype T | is_coroutine(T))
 void prime(T * cor);
+void prime(T & cor);
 //-----------------------------------------------------------------------------
 …
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
 static inline void resume(T * cor) {
+static inline void resume(T & cor) {
         coroutine_desc * src = this_coroutine;          // optimization
         coroutine_desc * dst = get_coroutine(cor);
 …
         if( unlikely(!dst->stack.base) ) {
                 create_stack(&dst->stack, dst->stack.size);
                 CtxStart(cor, CtxInvokeCoroutine);
+                CtxStart(&cor, CtxInvokeCoroutine);
+        }

src/libcfa/concurrency/coroutine.c

-              raf08051
+              r28e58fd
 //-----------------------------------------------------------------------------
 // Coroutine ctors and dtors
 void ?{}(coStack_t* this) {
         this->size              = 65000;        // size of stack
         this->storage   = NULL; // pointer to stack
         this->limit             = NULL; // stack grows towards stack limit
         this->base              = NULL; // base of stack
         this->context   = NULL; // address of cfa_context_t
         this->top               = NULL; // address of top of storage
         this->userStack = false;
+void ?{}(coStack_t& this) {
+        this.size               = 65000;        // size of stack
+        this.storage    = NULL; // pointer to stack
+        this.limit              = NULL; // stack grows towards stack limit
+        this.base               = NULL; // base of stack
+        this.context    = NULL; // address of cfa_context_t
+        this.top                = NULL; // address of top of storage
+        this.userStack  = false;
+}
 void ?{}(coStack_t* this, size_t size) {
+void ?{}(coStack_t& this, size_t size) {
         this{};
         this->size = size;
+        this.size = size;
         create_stack(this, this->size);
+        create_stack(&this, this.size);
+}
 void ?{}(coroutine_desc* this) {
+void ?{}(coroutine_desc& this) {
         this{ "Anonymous Coroutine" };
+}
 void ?{}(coroutine_desc* this, const char * name) {
         this->name = name;
         this->errno_ = 0;
         this->state = Start;
         this->starter = NULL;
         this->last = NULL;
+void ?{}(coroutine_desc& this, const char * name) {
+        this.name = name;
+        this.errno_ = 0;
+        this.state = Start;
+        this.starter = NULL;
+        this.last = NULL;
+}
 void ?{}(coroutine_desc* this, size_t size) {
+void ?{}(coroutine_desc& this, size_t size) {
         this{};
         (&this->stack){size};
+        (this.stack){size};
+}
 void ^?{}(coStack_t* this) {
         if ( ! this->userStack ) {
+void ^?{}(coStack_t& this) {
+        if ( ! this.userStack ) {
                 LIB_DEBUG_DO(
                         if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
                                 abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) );
+                        if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
+                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                        }
                 );
                 free( this->storage );
+                free( this.storage );
+        }
+}
 void ^?{}(coroutine_desc* this) {}
+void ^?{}(coroutine_desc& this) {}
 // Part of the Public API
 // Not inline since only ever called once per coroutine
 forall(dtype T | is_coroutine(T))
 void prime(T* cor) {
+void prime(T& cor) {
         coroutine_desc* this = get_coroutine(cor);
         assert(this->state == Start);

src/libcfa/concurrency/invoke.h

-              raf08051
+              r28e58fd
       #ifdef __CFORALL__
       extern "Cforall" {
             void ?{}( struct __thread_queue_t * );
+            void ?{}( struct __thread_queue_t & );
             void append( struct __thread_queue_t *, struct thread_desc * );
             struct thread_desc * pop_head( struct __thread_queue_t * );
             void ?{}( struct __condition_stack_t * );
+            void ?{}( struct __condition_stack_t & );
             void push( struct __condition_stack_t *, struct __condition_criterion_t * );
             struct __condition_criterion_t * pop( struct __condition_stack_t * );
             void ?{}(spinlock * this);
             void ^?{}(spinlock * this);
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
+      }
       #endif

src/libcfa/concurrency/kernel

-              raf08051
+              r28e58fd
 };
 void  ?{}(semaphore * this, int count = 1);
 void ^?{}(semaphore * this);
+void  ?{}(semaphore & this, int count = 1);
+void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
 …
 };
 void ?{}(cluster * this);
 void ^?{}(cluster * this);
+void ?{}(cluster & this);
+void ^?{}(cluster & this);
 //-----------------------------------------------------------------------------
 …
         unsigned short thrd_count;
 };
 static inline void ?{}(FinishAction * this) {
         this->action_code = No_Action;
         this->thrd = NULL;
         this->lock = NULL;
+static inline void ?{}(FinishAction & this) {
+        this.action_code = No_Action;
+        this.thrd = NULL;
+        this.lock = NULL;
+}
 static inline void ^?{}(FinishAction * this) {}
+static inline void ^?{}(FinishAction & this) {}
 // Processor
 …
 };
 void ?{}(processor * this);
 void ?{}(processor * this, cluster * cltr);
 void ^?{}(processor * this);
+void ?{}(processor & this);
+void ?{}(processor & this, cluster * cltr);
+void ^?{}(processor & this);
 // Local Variables: //

src/libcfa/concurrency/kernel.c

-              raf08051
+              r28e58fd
 };
 void ?{}( current_stack_info_t * this ) {
         CtxGet( this->ctx );
         this->base = this->ctx.FP;
         this->storage = this->ctx.SP;
+void ?{}( current_stack_info_t & this ) {
+        CtxGet( this.ctx );
+        this.base = this.ctx.FP;
+        this.storage = this.ctx.SP;
         rlimit r;
         getrlimit( RLIMIT_STACK, &r);
         this->size = r.rlim_cur;
         this->limit = (void *)(((intptr_t)this->base) - this->size);
         this->context = &storage_mainThreadCtx;
         this->top = this->base;
+}
 void ?{}( coStack_t * this, current_stack_info_t * info) {
         this->size = info->size;
         this->storage = info->storage;
         this->limit = info->limit;
         this->base = info->base;
         this->context = info->context;
         this->top = info->top;
         this->userStack = true;
+}
 void ?{}( coroutine_desc * this, current_stack_info_t * info) {
         (&this->stack){ info };
         this->name = "Main Thread";
         this->errno_ = 0;
         this->state = Start;
+}
 void ?{}( thread_desc * this, current_stack_info_t * info) {
         (&this->cor){ info };
+        this.size = r.rlim_cur;
+        this.limit = (void *)(((intptr_t)this.base) - this.size);
+        this.context = &storage_mainThreadCtx;
+        this.top = this.base;
+}
+void ?{}( coStack_t & this, current_stack_info_t * info) {
+        this.size = info->size;
+        this.storage = info->storage;
+        this.limit = info->limit;
+        this.base = info->base;
+        this.context = info->context;
+        this.top = info->top;
+        this.userStack = true;
+}
+void ?{}( coroutine_desc & this, current_stack_info_t * info) {
+        (this.stack){ info };
+        this.name = "Main Thread";
+        this.errno_ = 0;
+        this.state = Start;
+}
+void ?{}( thread_desc & this, current_stack_info_t * info) {
+        (this.cor){ info };
+}
 //-----------------------------------------------------------------------------
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
         (&this->__cor){ "Processor" };
         this->proc = proc;
         proc->runner = this;
+}
 void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
         (&this->__cor){ info };
         this->proc = proc;
         proc->runner = this;
+}
 void ?{}(processor * this) {
+void ?{}(processorCtx_t & this, processor * proc) {
+        (this.__cor){ "Processor" };
+        this.proc = proc;
+        proc->runner = &this;
+}
+void ?{}(processorCtx_t & this, processor * proc, current_stack_info_t * info) {
+        (this.__cor){ info };
+        this.proc = proc;
+        proc->runner = &this;
+}
+void ?{}(processor & this) {
         this{ mainCluster };
+}
 void ?{}(processor * this, cluster * cltr) {
         this->cltr = cltr;
         (&this->terminated){ 0 };
         this->do_terminate = false;
         this->preemption_alarm = NULL;
         this->pending_preemption = false;
         start( this );
+}
 void ?{}(processor * this, cluster * cltr, processorCtx_t * runner) {
         this->cltr = cltr;
         (&this->terminated){ 0 };
         this->do_terminate = false;
         this->preemption_alarm = NULL;
         this->pending_preemption = false;
         this->kernel_thread = pthread_self();
         this->runner = runner;
         LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", runner);
         runner{ this };
+}
 void ^?{}(processor * this) {
         if( ! this->do_terminate ) {
                 LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
                 this->do_terminate = true;
                 P( &this->terminated );
                 pthread_join( this->kernel_thread, NULL );
+        }
+}
 void ?{}(cluster * this) {
         ( &this->ready_queue ){};
         ( &this->ready_queue_lock ){};
         this->preemption = default_preemption();
+}
 void ^?{}(cluster * this) {
+void ?{}(processor & this, cluster * cltr) {
+        this.cltr = cltr;
+        (this.terminated){ 0 };
+        this.do_terminate = false;
+        this.preemption_alarm = NULL;
+        this.pending_preemption = false;
+        start( &this );
+}
+void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) {
+        this.cltr = cltr;
+        (this.terminated){ 0 };
+        this.do_terminate = false;
+        this.preemption_alarm = NULL;
+        this.pending_preemption = false;
+        this.kernel_thread = pthread_self();
+        this.runner = &runner;
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing main processor context %p\n", &runner);
+        runner{ &this };
+}
+void ^?{}(processor & this) {
+        if( ! this.do_terminate ) {
+                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", &this);
+                this.do_terminate = true;
+                P( &this.terminated );
+                pthread_join( this.kernel_thread, NULL );
+        }
+}
+void ?{}(cluster & this) {
+        ( this.ready_queue ){};
+        ( this.ready_queue_lock ){};
+        this.preemption = default_preemption();
+}
+void ^?{}(cluster & this) {
+}
 …
 //=============================================================================================
 //Main of the processor contexts
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
+void main(processorCtx_t & runner) {
+        processor * this = runner.proc;
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
 …
 // from the processor coroutine to the target thread
 void runThread(processor * this, thread_desc * dst) {
         coroutine_desc * proc_cor = get_coroutine(this->runner);
+        coroutine_desc * proc_cor = get_coroutine(*this->runner);
         coroutine_desc * thrd_cor = get_coroutine(dst);
 …
         // appropriate stack.
         proc_cor_storage.__cor.state = Active;
         main( &proc_cor_storage );
+        main( proc_cor_storage );
         proc_cor_storage.__cor.state = Halted;
 …
         mainThread = (thread_desc *)&storage_mainThread;
         current_stack_info_t info;
         mainThread{ &info };
+        (*mainThread){ &info };
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 …
         // Initialize the main cluster
         mainCluster = (cluster *)&storage_mainCluster;
         mainCluster{};
+        (*mainCluster){};
         LIB_DEBUG_PRINT_SAFE("Kernel : main cluster ready\n");
 …
         // (the coroutine that contains the processing control flow)
         mainProcessor = (processor *)&storage_mainProcessor;
         mainProcessor{ mainCluster, (processorCtx_t *)&storage_mainProcessorCtx };
+        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
         //initialize the global state variables
 …
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
         resume( mainProcessor->runner );
+        resume( *mainProcessor->runner );
 …
         // Destroy the main processor and its context in reverse order of construction
         // These were manually constructed so we need manually destroy them
         ^(mainProcessor->runner){};
+        ^(*mainProcessor->runner){};
         ^(mainProcessor){};
 …
 //-----------------------------------------------------------------------------
 // Locks
 void ?{}( spinlock * this ) {
         this->lock = 0;
+}
 void ^?{}( spinlock * this ) {
+void ?{}( spinlock & this ) {
+        this.lock = 0;
+}
+void ^?{}( spinlock & this ) {
+}
 …
+}
 void  ?{}( semaphore * this, int count = 1 ) {
         (&this->lock){};
         this->count = count;
         (&this->waiting){};
+}
 void ^?{}(semaphore * this) {}
+void  ?{}( semaphore & this, int count = 1 ) {
+        (this.lock){};
+        this.count = count;
+        (this.waiting){};
+}
+void ^?{}(semaphore & this) {}
 void P(semaphore * this) {
 …
 //-----------------------------------------------------------------------------
 // Queues
 void ?{}( __thread_queue_t * this ) {
         this->head = NULL;
         this->tail = &this->head;
+void ?{}( __thread_queue_t & this ) {
+        this.head = NULL;
+        this.tail = &this.head;
+}
 …
+}
 void ?{}( __condition_stack_t * this ) {
         this->top = NULL;
+void ?{}( __condition_stack_t & this ) {
+        this.top = NULL;
+}

src/libcfa/concurrency/monitor

-              raf08051
+              r28e58fd
 #include "stdlib"
 static inline void ?{}(monitor_desc * this) {
         this->owner = NULL;
         this->recursion = 0;
+static inline void ?{}(monitor_desc & this) {
+        this.owner = NULL;
+        this.recursion = 0;
+}
 …
+}
 void ?{}( monitor_guard_t * this, monitor_desc ** m, int count );
 void ^?{}( monitor_guard_t * this );
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count );
+void ^?{}( monitor_guard_t & this );
 //-----------------------------------------------------------------------------
 …
 };
 void ?{}( __condition_blocked_queue_t * );
+void ?{}( __condition_blocked_queue_t & );
 void append( __condition_blocked_queue_t *, __condition_node_t * );
 __condition_node_t * pop_head( __condition_blocked_queue_t * );
 …
 };
 static inline void ?{}( condition * this ) {
         this->monitors = NULL;
         this->monitor_count = 0;
+static inline void ?{}( condition & this ) {
+        this.monitors = NULL;
+        this.monitor_count = 0;
+}
 static inline void ^?{}( condition * this ) {
         free( this->monitors );
+static inline void ^?{}( condition & this ) {
+        free( this.monitors );
+}

src/libcfa/concurrency/monitor.c

-              raf08051
+              r28e58fd
+}
 void ?{}( monitor_guard_t * this, monitor_desc ** m, int count ) {
         this->m = m;
         this->count = count;
         qsort(this->m, count);
         enter( this->m, this->count );
         this->prev_mntrs = this_thread->current_monitors;
         this->prev_count = this_thread->current_monitor_count;
+void ?{}( monitor_guard_t & this, monitor_desc ** m, int count ) {
+        this.m = m;
+        this.count = count;
+        qsort(this.m, count);
+        enter( this.m, this.count );
+        this.prev_mntrs = this_thread->current_monitors;
+        this.prev_count = this_thread->current_monitor_count;
         this_thread->current_monitors      = m;
 …
+}
 void ^?{}( monitor_guard_t * this ) {
         leave( this->m, this->count );
         this_thread->current_monitors      = this->prev_mntrs;
         this_thread->current_monitor_count = this->prev_count;
+}
 void ?{}(__condition_node_t * this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
         this->waiting_thread = waiting_thread;
         this->count = count;
         this->next = NULL;
         this->user_info = user_info;
+}
 void ?{}(__condition_criterion_t * this ) {
         this->ready  = false;
         this->target = NULL;
         this->owner  = NULL;
         this->next   = NULL;
+}
 void ?{}(__condition_criterion_t * this, monitor_desc * target, __condition_node_t * owner ) {
         this->ready  = false;
         this->target = target;
         this->owner  = owner;
         this->next   = NULL;
+void ^?{}( monitor_guard_t & this ) {
+        leave( this.m, this.count );
+        this_thread->current_monitors      = this.prev_mntrs;
+        this_thread->current_monitor_count = this.prev_count;
+}
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, unsigned short count, uintptr_t user_info ) {
+        this.waiting_thread = waiting_thread;
+        this.count = count;
+        this.next = NULL;
+        this.user_info = user_info;
+}
+void ?{}(__condition_criterion_t & this ) {
+        this.ready  = false;
+        this.target = NULL;
+        this.owner  = NULL;
+        this.next   = NULL;
+}
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner ) {
+        this.ready  = false;
+        this.target = target;
+        this.owner  = owner;
+        this.next   = NULL;
+}
 …
         __condition_criterion_t criteria[count];
         for(int i = 0; i < count; i++) {
                 (&criteria[i]){ this->monitors[i], &waiter };
+                (criteria[i]){ this->monitors[i], &waiter };
                 // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
+        }
 …
         __condition_criterion_t criteria[count];
         for(int i = 0; i < count; i++) {
                 (&criteria[i]){ this->monitors[i], &waiter };
+                (criteria[i]){ this->monitors[i], &waiter };
                 // LIB_DEBUG_PRINT_SAFE( "Criterion %p\n", &criteria[i] );
                 push( &criteria[i].target->signal_stack, &criteria[i] );
 …
+}
 void ?{}( __condition_blocked_queue_t * this ) {
         this->head = NULL;
         this->tail = &this->head;
+void ?{}( __condition_blocked_queue_t & this ) {
+        this.head = NULL;
+        this.tail = &this.head;
+}

src/libcfa/concurrency/preemption.c

-              raf08051
+              r28e58fd
 static pthread_t alarm_thread;                        // pthread handle to alarm thread
 void ?{}(event_kernel_t * this) {
         (&this->alarms){};
         (&this->lock){};
+void ?{}(event_kernel_t & this) {
+        (this.alarms){};
+        (this.lock){};
+}
 …
         // Initialize the event kernel
         event_kernel = (event_kernel_t *)&storage_event_kernel;
         event_kernel{};
+        (*event_kernel){};
         // Setup proper signal handlers
 …
 // Raii ctor/dtor for the preemption_scope
 // Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope * this, processor * proc ) {
         (&this->alarm){ proc, zero_time, zero_time };
         this->proc = proc;
         this->proc->preemption_alarm = &this->alarm;
         update_preemption( this->proc, from_us(this->proc->cltr->preemption) );
+}
 void ^?{}( preemption_scope * this ) {
+void ?{}( preemption_scope & this, processor * proc ) {
+        (this.alarm){ proc, zero_time, zero_time };
+        this.proc = proc;
+        this.proc->preemption_alarm = &this.alarm;
+        update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
+}
+void ^?{}( preemption_scope & this ) {
         disable_interrupts();
         update_preemption( this->proc, zero_time );
+        update_preemption( this.proc, zero_time );
+}

src/libcfa/concurrency/preemption.h

-              raf08051
+              r28e58fd
 };
 void ?{}( preemption_scope * this, processor * proc );
 void ^?{}( preemption_scope * this );
+void ?{}( preemption_scope & this, processor * proc );
+void ^?{}( preemption_scope & this );
 // Local Variables: //

src/libcfa/concurrency/thread

-              raf08051
+              r28e58fd
 // Anything that is resumed is a coroutine.
 trait is_thread(dtype T) {
       void ^?{}(T* mutex this);
       void main(T* this);
       thread_desc* get_thread(T* this);
+      void ^?{}(T& mutex this);
+      void main(T& this);
+      thread_desc* get_thread(T& this);
 };
 #define DECL_THREAD(X) thread_desc* get_thread(X* this) { return &this->__thrd; } void main(X* this)
+#define DECL_THREAD(X) thread_desc* get_thread(X& this) { return &this.__thrd; } void main(X& this)
 forall( dtype T | is_thread(T) )
 static inline coroutine_desc* get_coroutine(T* this) {
+static inline coroutine_desc* get_coroutine(T & this) {
         return &get_thread(this)->cor;
+}
 forall( dtype T | is_thread(T) )
 static inline monitor_desc* get_monitor(T * this) {
+static inline monitor_desc* get_monitor(T & this) {
         return &get_thread(this)->mon;
+}
 …
 forall( dtype T | is_thread(T) )
 void __thrd_start( T* this );
+void __thrd_start( T & this );
 //-----------------------------------------------------------------------------
 // Ctors and dtors
 void ?{}(thread_desc* this);
 void ^?{}(thread_desc* this);
+void ?{}(thread_desc& this);
+void ^?{}(thread_desc& this);
 //-----------------------------------------------------------------------------
 …
 };
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
 void ?{}( scoped(T)* this );
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this );
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
 void ?{}( scoped(T)* this, P params );
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params );
 forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this );
+void ^?{}( scoped(T)& this );
 void yield();

src/libcfa/concurrency/thread.c

-              raf08051
+              r28e58fd
 // Thread ctors and dtors
 void ?{}(thread_desc* this) {
         (&this->cor){};
         this->cor.name = "Anonymous Coroutine";
         this->mon.owner = this;
         this->mon.recursion = 1;
         this->next = NULL;
+void ?{}(thread_desc& this) {
+        (this.cor){};
+        this.cor.name = "Anonymous Coroutine";
+        this.mon.owner = &this;
+        this.mon.recursion = 1;
+        this.next = NULL;
         this->current_monitors      = &this->mon;
         this->current_monitor_count = 1;
+        this.current_monitors      = &this.mon;
+        this.current_monitor_count = 1;
+}
 void ^?{}(thread_desc* this) {
         ^(&this->cor){};
+void ^?{}(thread_desc& this) {
+        ^(this.cor){};
+}
 forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T*); } )
 void ?{}( scoped(T)* this ) {
         (&this->handle){};
         __thrd_start(&this->handle);
+forall( dtype T | sized(T) | is_thread(T) | { void ?{}(T&); } )
+void ?{}( scoped(T)& this ) {
+        (this.handle){};
+        __thrd_start(this.handle);
+}
 forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T*, P); } )
 void ?{}( scoped(T)* this, P params ) {
         (&this->handle){ params };
         __thrd_start(&this->handle);
+forall( dtype T, ttype P | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
+void ?{}( scoped(T)& this, P params ) {
+        (this.handle){ params };
+        __thrd_start(this.handle);
+}
 forall( dtype T | sized(T) | is_thread(T) )
 void ^?{}( scoped(T)* this ) {
         ^(&this->handle){};
+void ^?{}( scoped(T)& this ) {
+        ^(this.handle){};
+}
 …
 // Starting and stopping threads
 forall( dtype T | is_thread(T) )
 void __thrd_start( T* this ) {
+void __thrd_start( T& this ) {
         coroutine_desc* thrd_c = get_coroutine(this);
         thread_desc*  thrd_h = get_thread   (this);
 …
         create_stack(&thrd_c->stack, thrd_c->stack.size);
         this_coroutine = thrd_c;
         CtxStart(this, CtxInvokeThread);
+        CtxStart(&this, CtxInvokeThread);
         assert( thrd_c->last->stack.context );
         CtxSwitch( thrd_c->last->stack.context, thrd_c->stack.context );

src/libcfa/containers/maybe

-              raf08051
+              r28e58fd
 forall(otype T)
 void ?{}(maybe(T) * this);
+void ?{}(maybe(T) & this);
 forall(otype T)
 void ?{}(maybe(T) * this, T value);
+void ?{}(maybe(T) & this, T value);
 forall(otype T)
 void ?{}(maybe(T) * this, maybe(T) other);
+void ?{}(maybe(T) & this, maybe(T) other);
 forall(otype T)
 void ^?{}(maybe(T) * this);
+void ^?{}(maybe(T) & this);
 forall(otype T)
 maybe(T) ?=?(maybe(T) * this, maybe(T) other);
+maybe(T) ?=?(maybe(T) & this, maybe(T) other);
 forall(otype T)

src/libcfa/containers/maybe.c

-              raf08051
+              r28e58fd
 forall(otype T)
 void ?{}(maybe(T) * this) {
         this->has_value = false;
+void ?{}(maybe(T) & this) {
+        this.has_value = false;
+}
 forall(otype T)
 void ?{}(maybe(T) * this, T value) {
         this->has_value = true;
         (&this->value){value};
+void ?{}(maybe(T) & this, T value) {
+        this.has_value = true;
+        (this.value){value};
+}
 forall(otype T)
 void ?{}(maybe(T) * this, maybe(T) other) {
         this->has_value = other.has_value;
+void ?{}(maybe(T) & this, maybe(T) other) {
+        this.has_value = other.has_value;
         if (other.has_value) {
                 (&this->value){other.value};
+                (this.value){other.value};
+        }
+}
 forall(otype T)
 maybe(T) ?=?(maybe(T) * this, maybe(T) that) {
         if (this->has_value & that.has_value) {
                 this->value = that.value;
         } else if (this->has_value) {
                 ^(&this->value){};
                 this->has_value = false;
+maybe(T) ?=?(maybe(T) & this, maybe(T) that) {
+        if (this.has_value & that.has_value) {
+                this.value = that.value;
+        } else if (this.has_value) {
+                ^(this.value){};
+                this.has_value = false;
         } else if (that.has_value) {
                 this->has_value = true;
                 (&this->value){that.value};
+                this.has_value = true;
+                (this.value){that.value};
+        }
+        return this;
+}
 forall(otype T)
 void ^?{}(maybe(T) * this) {
         if (this->has_value) {
                 ^(&this->value){};
+void ^?{}(maybe(T) & this) {
+        if (this.has_value) {
+                ^(this.value){};
+        }
+}
 …
         } else {
                 this->has_value = true;
                 (&this->value){value};
+                (this->value){value};
+        }
+}
 …
         if (this->has_value) {
                 this->has_value = false;
                 ^(&this->value){};
+                ^(this->value){};
+        }
+}

src/libcfa/containers/result

-              raf08051
+              r28e58fd
 forall(otype T, otype E)
 void ?{}(result(T, E) * this);
+void ?{}(result(T, E) & this);
 forall(otype T, otype E)
 void ?{}(result(T, E) * this, one_t, T value);
+void ?{}(result(T, E) & this, one_t, T value);
 forall(otype T, otype E)
 void ?{}(result(T, E) * this, zero_t, E error);
+void ?{}(result(T, E) & this, zero_t, E error);
 forall(otype T, otype E)
 void ?{}(result(T, E) * this, result(T, E) other);
+void ?{}(result(T, E) & this, result(T, E) other);
 forall(otype T, otype E)
 void ^?{}(result(T, E) * this);
+void ^?{}(result(T, E) & this);
 forall(otype T, otype E)
 result(T, E) ?=?(result(T, E) * this, result(T, E) other);
+result(T, E) ?=?(result(T, E) & this, result(T, E) other);
 forall(otype T, otype E)

src/libcfa/containers/result.c

-              raf08051
+              r28e58fd
 forall(otype T, otype E)
 void ?{}(result(T, E) * this) {
         this->has_value = false;
         (&this->error){};
+void ?{}(result(T, E) & this) {
+        this.has_value = false;
+        (this.error){};
+}
 forall(otype T, otype E)
 void ?{}(result(T, E) * this, one_t, T value) {
         this->has_value = true;
         (&this->value){value};
+void ?{}(result(T, E) & this, one_t, T value) {
+        this.has_value = true;
+        (this.value){value};
+}
 forall(otype T, otype E)
 void ?{}(result(T, E) * this, zero_t, E error) {
         this->has_value = false;
         (&this->error){error};
+void ?{}(result(T, E) & this, zero_t, E error) {
+        this.has_value = false;
+        (this.error){error};
+}
 forall(otype T, otype E)
 void ?{}(result(T, E) * this, result(T, E) other) {
         this->has_value = other.has_value;
+void ?{}(result(T, E) & this, result(T, E) other) {
+        this.has_value = other.has_value;
         if (other.has_value) {
                 (&this->value){other.value};
+                (this.value){other.value};
         } else {
                 (&this->error){other.error};
+                (this.error){other.error};
+        }
+}
 forall(otype T, otype E)
 result(T, E) ?=?(result(T, E) * this, result(T, E) that) {
         if (this->has_value & that.has_value) {
                 this->value = that.value;
         } else if (this->has_value) {
                 ^(&this->value){};
                 this->has_value = false;
                 (&this->error){that.error};
+result(T, E) ?=?(result(T, E) & this, result(T, E) that) {
+        if (this.has_value & that.has_value) {
+                this.value = that.value;
+        } else if (this.has_value) {
+                ^(this.value){};
+                this.has_value = false;
+                (this.error){that.error};
         } else if (that.has_value) {
                 ^(&this->error){};
                 this->has_value = true;
                 (&this->value){that.value};
+                ^(this.error){};
+                this.has_value = true;
+                (this.value){that.value};
         } else {
                 this->error = that.error;
+                this.error = that.error;
+        }
+}
 forall(otype T, otype E)
 void ^?{}(result(T, E) * this) {
         if (this->has_value) {
                 ^(&this->value){};
+void ^?{}(result(T, E) & this) {
+        if (this.has_value) {
+                ^(this.value){};
         } else {
                 ^(&this->error){};
+                ^(this.error){};
+        }
+}
 …
                 this->value = value;
         } else {
                 ^(&this->error){};
+                ^(this->error){};
                 this->has_value = true;
                 (&this->value){value};
+                (this->value){value};
+        }
+}
 …
 void set_error(result(T, E) * this, E error) {
         if (this->has_value) {
                 ^(&this->value){};
+                ^(this->value){};
                 this->has_value = false;
                 (&this->error){error};
+                (this->error){error};
         } else {
                 this->error = error;

src/libcfa/containers/vector

-              raf08051
+              r28e58fd
 forall(otype T)
 void ?{}(heap_allocator(T)* this);
+void ?{}(heap_allocator(T)& this);
 forall(otype T)
 void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs);
+void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs);
 forall(otype T)
 heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs);
+heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs);
 forall(otype T)
 void ^?{}(heap_allocator(T)* this);
+void ^?{}(heap_allocator(T)& this);
 forall(otype T)
 …
 //Initialization
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
 void ?{}(vector(T, allocator_t)* this);
+void ?{}(vector(T, allocator_t)& this);
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
 void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
+void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs);
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
 vector(T, allocator_t) ?=?(vector(T, allocator_t)* this, vector(T, allocator_t) rhs);
+vector(T, allocator_t) ?=?(vector(T, allocator_t)& this, vector(T, allocator_t) rhs);
 forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
 void ^?{}(vector(T, allocator_t)* this);
+void ^?{}(vector(T, allocator_t)& this);
 forall(otype T, otype allocator_t = heap_allocator(T) | allocator_c(T, allocator_t))

src/libcfa/containers/vector.c

raf08051	r28e58fd
24	24	//Initialization
25	25	forall(otype T, otype allocator_t \| allocator_c(T, allocator_t))
26		void ?{}(vector(T, allocator_t)* this)
	26	void ?{}(vector(T, allocator_t)& this)
27	27	{
28		(~~&this->~~storage){};
29		this->size = 0;
	28	(this.storage){};
	29	this.size = 0;
30	30	}
31	31
32	32	forall(otype T, otype allocator_t \| allocator_c(T, allocator_t))
33		void ?{}(vector(T, allocator_t)* this, vector(T, allocator_t) rhs)
	33	void ?{}(vector(T, allocator_t)& this, vector(T, allocator_t) rhs)
34	34	{
35		(~~&this->~~storage){ rhs.storage };
36		copy_internal(this, &rhs);
	35	(this.storage){ rhs.storage };
	36	copy_internal(&this, &rhs);
37	37	}
38	38
…	…
46	46
47	47	forall(otype T, otype allocator_t \| allocator_c(T, allocator_t))
48		void ^?{}(vector(T, allocator_t)* this)
	48	void ^?{}(vector(T, allocator_t)& this)
49	49	{
50		clear(this);
51		^(~~&this->~~storage){};
	50	clear(&this);
	51	^(this.storage){};
52	52	}
53	53
…	…
66	66	{
67	67	this->size--;
68		^(&data(&this->storage)[this->size]){};
	68	^(data(&this->storage)[this->size]){};
69	69	}
70	70
…	…
74	74	for(size_t i = 0; i < this->size; i++)
75	75	{
76		^(&data(&this->storage)[this->size]){};
	76	^(data(&this->storage)[this->size]){};
77	77	}
78	78	this->size = 0;
…	…
87	87	this->size = other->size;
88	88	for(size_t i = 0; i < this->size; i++) {
89		(&data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
	89	(data(&this->storage)[this->size]){ data(&other->storage)[other->size] };
90	90	}
91	91	}
…	…
94	94	//Allocator
95	95	forall(otype T)
96		void ?{}(heap_allocator(T)* this)
	96	void ?{}(heap_allocator(T)& this)
97	97	{
98		this->storage = 0;
99		this->capacity = 0;
	98	this.storage = 0;
	99	this.capacity = 0;
100	100	}
101	101
102	102	forall(otype T)
103		void ?{}(heap_allocator(T)* this, heap_allocator(T) rhs)
	103	void ?{}(heap_allocator(T)& this, heap_allocator(T) rhs)
104	104	{
105		this->capacity = rhs.capacity;
106		this~~->storage = (T)realloc((void)this->storage, this->~~capacity * sizeof(T));
	105	this.capacity = rhs.capacity;
	106	this.storage = (T)realloc((void)this.storage, this.capacity * sizeof(T));
107	107	}
108	108
109	109	forall(otype T)
110		heap_allocator(T) ?=?(heap_allocator(T)* this, heap_allocator(T) rhs)
	110	heap_allocator(T) ?=?(heap_allocator(T)& this, heap_allocator(T) rhs)
111	111	{
112		this->capacity = rhs.capacity;
113		this~~->storage = (T)realloc((void)this->storage, this->~~capacity * sizeof(T));
114		return *this;
	112	this.capacity = rhs.capacity;
	113	this.storage = (T)realloc((void)this.storage, this.capacity * sizeof(T));
	114	return this;
115	115	}
116	116
117	117	forall(otype T)
118		void ^?{}(heap_allocator(T)* this)
	118	void ^?{}(heap_allocator(T)& this)
119	119	{
120		free(this->storage);
	120	free(this.storage);
121	121	}
122	122

src/libcfa/fstream

raf08051	r28e58fd
56	56	int fmt( ofstream *, const char fmt[], ... );
57	57
58		void ?{}( ofstream * );
	58	void ?{}( ofstream & );
59	59
60	60	extern ofstream * sout, * serr;

src/libcfa/fstream.c

-              raf08051
+              r28e58fd
 #define IO_MSG "I/O error: "
 void ?{}( ofstream * this, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) {
         this->file = file;
         this->sepDefault = sepDefault;
         this->sepOnOff = sepOnOff;
         sepSet( this, separator );
         sepSetCur( this, sepGet( this ) );
         sepSetTuple( this, tupleSeparator );
+void ?{}( ofstream & this, void * file, _Bool sepDefault, _Bool sepOnOff, const char * separator, const char * tupleSeparator ) {
+        this.file = file;
+        this.sepDefault = sepDefault;
+        this.sepOnOff = sepOnOff;
+        sepSet( &this, separator );
+        sepSetCur( &this, sepGet( &this ) );
+        sepSetTuple( &this, tupleSeparator );
+}
 …
                 exit( EXIT_FAILURE );
         } // if
         ?{}( os, file, true, false, " ", ", " );
+        ?{}( *os, file, true, false, " ", ", " );
 } // open

src/libcfa/gmp

-              raf08051
+              r28e58fd
 //
+//
 // 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.
 //
 // gmp --
 //
+//
+// gmp --
+//
 // Author           : Peter A. Buhr
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul  7 09:33:20 2017
 // Update Count     : 15
 //
+// Last Modified On : Thu Aug 24 09:24:51 2017
+// Update Count     : 16
+//
 // https://gmplib.org/gmp-man-6.1.1.pdf
 …
 // constructor
 static inline void ?{}( Int * this ) { mpz_init( this->mpz ); }
 static inline void ?{}( Int * this, Int init ) { mpz_init_set( this->mpz, init.mpz ); }
 static inline void ?{}( Int * this, zero_t ) { mpz_init_set_si( this->mpz, 0 ); }
 static inline void ?{}( Int * this, one_t ) { mpz_init_set_si( this->mpz, 1 ); }
 static inline void ?{}( Int * this, signed long int init ) { mpz_init_set_si( this->mpz, init ); }
 static inline void ?{}( Int * this, unsigned long int init ) { mpz_init_set_ui( this->mpz, init ); }
 static inline void ?{}( Int * this, const char * val ) { if ( mpz_init_set_str( this->mpz, val, 0 ) ) abort(); }
 static inline void ^?{}( Int * this ) { mpz_clear( this->mpz ); }
+static inline void ?{}( Int & this ) { mpz_init( this.mpz ); }
+static inline void ?{}( Int & this, Int init ) { mpz_init_set( this.mpz, init.mpz ); }
+static inline void ?{}( Int & this, zero_t ) { mpz_init_set_si( this.mpz, 0 ); }
+static inline void ?{}( Int & this, one_t ) { mpz_init_set_si( this.mpz, 1 ); }
+static inline void ?{}( Int & this, signed long int init ) { mpz_init_set_si( this.mpz, init ); }
+static inline void ?{}( Int & this, unsigned long int init ) { mpz_init_set_ui( this.mpz, init ); }
+static inline void ?{}( Int & this, const char * val ) { if ( mpz_init_set_str( this.mpz, val, 0 ) ) abort(); }
+static inline void ^?{}( Int & this ) { mpz_clear( this.mpz ); }
 // assignment
 static inline Int ?=?( Int * lhs, Int rhs ) { mpz_set( lhs->mpz, rhs.mpz ); return *lhs; }
 static inline Int ?=?( Int * lhs, long int rhs ) { mpz_set_si( lhs->mpz, rhs ); return *lhs; }
 static inline Int ?=?( Int * lhs, unsigned long int rhs ) { mpz_set_ui( lhs->mpz, rhs ); return *lhs; }
 static inline Int ?=?( Int * lhs, const char * rhs ) { if ( mpz_set_str( lhs->mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return *lhs; }
 static inline char ?=?( char * lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 static inline short int ?=?( short int * lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 static inline int ?=?( int * lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 static inline long int ?=?( long int * lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); *lhs = val; return val; }
 static inline unsigned char ?=?( unsigned char * lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 static inline unsigned short int ?=?( unsigned short int * lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 static inline unsigned int ?=?( unsigned int * lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
 static inline unsigned long int ?=?( unsigned long int * lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); *lhs = val; return val; }
+static inline Int ?=?( Int & lhs, Int rhs ) { mpz_set( lhs.mpz, rhs.mpz ); return lhs; }
+static inline Int ?=?( Int & lhs, long int rhs ) { mpz_set_si( lhs.mpz, rhs ); return lhs; }
+static inline Int ?=?( Int & lhs, unsigned long int rhs ) { mpz_set_ui( lhs.mpz, rhs ); return lhs; }
+static inline Int ?=?( Int & lhs, const char * rhs ) { if ( mpz_set_str( lhs.mpz, rhs, 0 ) ) { printf( "invalid string conversion\n" ); abort(); } return lhs; }
+static inline char ?=?( char & lhs, Int rhs ) { char val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
+static inline short int ?=?( short int & lhs, Int rhs ) { short int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
+static inline int ?=?( int & lhs, Int rhs ) { int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
+static inline long int ?=?( long int & lhs, Int rhs ) { long int val = mpz_get_si( rhs.mpz ); lhs = val; return lhs; }
+static inline unsigned char ?=?( unsigned char & lhs, Int rhs ) { unsigned char val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
+static inline unsigned short int ?=?( unsigned short int & lhs, Int rhs ) { unsigned short int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
+static inline unsigned int ?=?( unsigned int & lhs, Int rhs ) { unsigned int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
+static inline unsigned long int ?=?( unsigned long int & lhs, Int rhs ) { unsigned long int val = mpz_get_ui( rhs.mpz ); lhs = val; return lhs; }
 // conversions
 …
 static inline Int ?&?( Int oper1, unsigned long int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_and( conjunction.mpz, oper1.mpz, temp.mpz ); return conjunction; }
 static inline Int ?&?( unsigned long int oper1, Int oper2 ) { Int conjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_and( conjunction.mpz, temp.mpz, oper2.mpz ); return conjunction; }
 static inline Int ?&=?( Int * lhs, Int rhs ) { return *lhs = *lhs & rhs; }
+static inline Int ?&=?( Int & lhs, Int rhs ) { return lhs = lhs & rhs; }
 static inline Int ?|?( Int oper1, Int oper2 ) { Int disjunction; mpz_ior( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
 …
 static inline Int ?|?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
 static inline Int ?|?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
 static inline Int ?|=?( Int * lhs, Int rhs ) { return *lhs = *lhs | rhs; }
+static inline Int ?|=?( Int & lhs, Int rhs ) { return lhs = lhs | rhs; }
 static inline Int ?^?( Int oper1, Int oper2 ) { Int disjunction; mpz_xor( disjunction.mpz, oper1.mpz, oper2.mpz ); return disjunction; }
 …
 static inline Int ?^?( Int oper1, unsigned long int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper2 ); mpz_ior( disjunction.mpz, oper1.mpz, temp.mpz ); return disjunction; }
 static inline Int ?^?( unsigned long int oper1, Int oper2 ) { Int disjunction, temp; mpz_set_ui( temp.mpz, oper1 ); mpz_ior( disjunction.mpz, temp.mpz, oper2.mpz ); return disjunction; }
 static inline Int ?^=?( Int * lhs, Int rhs ) { return *lhs = *lhs ^ rhs; }
+static inline Int ?^=?( Int & lhs, Int rhs ) { return lhs = lhs ^ rhs; }
 static inline Int ?+?( Int addend1, Int addend2 ) { Int sum; mpz_add( sum.mpz, addend1.mpz, addend2.mpz ); return sum; }
 …
 static inline Int ?+?( Int addend1, unsigned long int addend2 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
 static inline Int ?+?( unsigned long int addend2, Int addend1 ) { Int sum; mpz_add_ui( sum.mpz, addend1.mpz, addend2 ); return sum; }
 static inline Int ?+=?( Int * lhs, Int rhs ) { return *lhs = *lhs + rhs; }
 static inline Int ?+=?( Int * lhs, long int rhs ) { return *lhs = *lhs + rhs; }
 static inline Int ?+=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs + rhs; }
 static inline Int ++?( Int * lhs ) { return *lhs += 1; }
 static inline Int ?++( Int * lhs ) { Int ret = *lhs; *lhs += 1; return ret; }
+static inline Int ?+=?( Int & lhs, Int rhs ) { return lhs = lhs + rhs; }
+static inline Int ?+=?( Int & lhs, long int rhs ) { return lhs = lhs + rhs; }
+static inline Int ?+=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs + rhs; }
+static inline Int ++?( Int & lhs ) { return lhs += 1; }
+static inline Int ?++( Int & lhs ) { Int ret = lhs; lhs += 1; return ret; }
 static inline Int ?-?( Int minuend, Int subtrahend ) { Int diff; mpz_sub( diff.mpz, minuend.mpz, subtrahend.mpz ); return diff; }
 …
 static inline Int ?-?( Int minuend, unsigned long int subtrahend ) { Int diff; mpz_sub_ui( diff.mpz, minuend.mpz, subtrahend ); return diff; }
 static inline Int ?-?( unsigned long int minuend, Int subtrahend ) { Int diff; mpz_ui_sub( diff.mpz, minuend, subtrahend.mpz ); return diff; }
 static inline Int ?-=?( Int * lhs, Int rhs ) { return *lhs = *lhs - rhs; }
 static inline Int ?-=?( Int * lhs, long int rhs ) { return *lhs = *lhs - rhs; }
 static inline Int ?-=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs - rhs; }
 static inline Int --?( Int * lhs ) { return *lhs -= 1; }
 static inline Int ?--( Int * lhs ) { Int ret = *lhs; *lhs -= 1; return ret; }
+static inline Int ?-=?( Int & lhs, Int rhs ) { return lhs = lhs - rhs; }
+static inline Int ?-=?( Int & lhs, long int rhs ) { return lhs = lhs - rhs; }
+static inline Int ?-=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs - rhs; }
+static inline Int --?( Int & lhs ) { return lhs -= 1; }
+static inline Int ?--( Int & lhs ) { Int ret = lhs; lhs -= 1; return ret; }
 static inline Int ?*?( Int multiplicator, Int multiplicand ) { Int product; mpz_mul( product.mpz, multiplicator.mpz, multiplicand.mpz ); return product; }
 …
 static inline Int ?*?( Int multiplicator, unsigned long int multiplicand ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
 static inline Int ?*?( unsigned long int multiplicand, Int multiplicator ) { Int product; mpz_mul_ui( product.mpz, multiplicator.mpz, multiplicand ); return product; }
 static inline Int ?*=?( Int * lhs, Int rhs ) { return *lhs = *lhs * rhs; }
 static inline Int ?*=?( Int * lhs, long int rhs ) { return *lhs = *lhs * rhs; }
 static inline Int ?*=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs * rhs; }
+static inline Int ?*=?( Int & lhs, Int rhs ) { return lhs = lhs * rhs; }
+static inline Int ?*=?( Int & lhs, long int rhs ) { return lhs = lhs * rhs; }
+static inline Int ?*=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs * rhs; }
 // some code for operators "/" and "%" taken from g++ gmpxx.h
 …
         return quotient;
 } // ?/?
 static inline Int ?/=?( Int * lhs, Int rhs ) { return *lhs = *lhs / rhs; }
 static inline Int ?/=?( Int * lhs, long int rhs ) { return *lhs = *lhs / rhs; }
 static inline Int ?/=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs / rhs; }
+static inline Int ?/=?( Int & lhs, Int rhs ) { return lhs = lhs / rhs; }
+static inline Int ?/=?( Int & lhs, long int rhs ) { return lhs = lhs / rhs; }
+static inline Int ?/=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs / rhs; }
 static inline [ Int, Int ] div( Int dividend, Int divisor ) { Int quotient, remainder; mpz_fdiv_qr( quotient.mpz, remainder.mpz, dividend.mpz, divisor.mpz ); return [ quotient, remainder ]; }
 …
         return remainder;
 } // ?%?
 static inline Int ?%=?( Int * lhs, Int rhs ) { return *lhs = *lhs % rhs; }
 static inline Int ?%=?( Int * lhs, long int rhs ) { return *lhs = *lhs % rhs; }
 static inline Int ?%=?( Int * lhs, unsigned long int rhs ) { return *lhs = *lhs % rhs; }
+static inline Int ?%=?( Int & lhs, Int rhs ) { return lhs = lhs % rhs; }
+static inline Int ?%=?( Int & lhs, long int rhs ) { return lhs = lhs % rhs; }
+static inline Int ?%=?( Int & lhs, unsigned long int rhs ) { return lhs = lhs % rhs; }
 static inline Int ?<<?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_mul_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
 static inline Int ?<<=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs << shift; }
+static inline Int ?<<=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs << shift; }
 static inline Int ?>>?( Int shiften, mp_bitcnt_t shift ) { Int shifted; mpz_fdiv_q_2exp( shifted.mpz, shiften.mpz, shift ); return shifted; }
 static inline Int ?>>=?( Int * lhs, mp_bitcnt_t shift ) { return *lhs = *lhs >> shift; }
+static inline Int ?>>=?( Int & lhs, mp_bitcnt_t shift ) { return lhs = lhs >> shift; }
 // number functions
 …
 // I/O
 static inline forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, Int * mp ) {
         gmp_scanf( "%Zd", mp );
+istype * ?|?( istype * is, Int & mp ) {
+        gmp_scanf( "%Zd", &mp );
         return is;
 } // ?|?

src/libcfa/interpose.c

-              raf08051
+              r28e58fd
         union { generic_fptr_t fptr; void* ptr; } originalFunc;
         #if defined( _GNU_SOURCE )
                 if ( version ) {
 …
                 originalFunc.ptr = dlsym( library, symbol );
         #endif // _GNU_SOURCE
         error = dlerror();
         if ( error ) abortf( "interpose_symbol : internal error, %s\n", error );
+        if ( error ) abortf( "interpose_symbol : internal error, %s\n", error );
         return originalFunc.fptr;
 …
 forall(dtype T)
 static inline void assign_ptr( T** symbol_ptr, const char * symbol_name, const char * version) {
         union {
+        union {
                 generic_fptr_t gp;
                 T* tp;
+                T* tp;
         } u;

src/libcfa/iostream

-              raf08051
+              r28e58fd
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug  9 16:42:47 2017
 // Update Count     : 131
+// Last Modified On : Thu Aug 24 08:14:29 2017
+// Update Count     : 133
 //
 …
 }; // readable
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, char & );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned short int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long long int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long int * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long long int * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, short int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned short int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long long int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long int & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, unsigned long long int & );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double & );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float _Complex * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double _Complex * );
 forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex * );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, float _Complex & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, double _Complex & );
+forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, long double _Complex & );
 struct _Istream_cstrUC { char * s; };

src/libcfa/iostream.c

-              raf08051
+              r28e58fd
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Aug  9 16:46:51 2017
 // Update Count     : 401
+// Last Modified On : Thu Aug 24 08:41:53 2017
+// Update Count     : 405
 //
 …
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, char * c ) {
         fmt( is, "%c", c );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, short int * si ) {
         fmt( is, "%hd", si );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, unsigned short int * usi ) {
         fmt( is, "%hu", usi );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, int * i ) {
         fmt( is, "%d", i );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, unsigned int * ui ) {
         fmt( is, "%u", ui );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, long int * li ) {
         fmt( is, "%ld", li );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, unsigned long int * ulli ) {
         fmt( is, "%lu", ulli );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, long long int * lli ) {
         fmt( is, "%lld", lli );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, unsigned long long int * ulli ) {
         fmt( is, "%llu", ulli );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, float * f ) {
         fmt( is, "%f", f );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, double * d ) {
         fmt( is, "%lf", d );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, long double * ld ) {
         fmt( is, "%Lf", ld );
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, float _Complex * fc ) {
+istype * ?|?( istype * is, char & c ) {
+        fmt( is, "%c", &c );                                                            // must pass pointer through varg to fmt
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, short int & si ) {
+        fmt( is, "%hd", &si );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned short int & usi ) {
+        fmt( is, "%hu", &usi );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, int & i ) {
+        fmt( is, "%d", &i );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned int & ui ) {
+        fmt( is, "%u", &ui );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long int & li ) {
+        fmt( is, "%ld", &li );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned long int & ulli ) {
+        fmt( is, "%lu", &ulli );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long long int & lli ) {
+        fmt( is, "%lld", &lli );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, unsigned long long int & ulli ) {
+        fmt( is, "%llu", &ulli );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, float & f ) {
+        fmt( is, "%f", &f );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, double & d ) {
+        fmt( is, "%lf", &d );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long double & ld ) {
+        fmt( is, "%Lf", &ld );
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, float _Complex & fc ) {
         float re, im;
         fmt( is, "%g%gi", &re, &im );
         *fc = re + im * _Complex_I;
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, double _Complex * dc ) {
+        fc = re + im * _Complex_I;
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, double _Complex & dc ) {
         double re, im;
         fmt( is, "%lf%lfi", &re, &im );
         *dc = re + im * _Complex_I;
         return is;
 } // ?|?
 forall( dtype istype | istream( istype ) )
 istype * ?|?( istype * is, long double _Complex * ldc ) {
+        dc = re + im * _Complex_I;
+        return is;
+} // ?|?
+forall( dtype istype | istream( istype ) )
+istype * ?|?( istype * is, long double _Complex & ldc ) {
         long double re, im;
         fmt( is, "%Lf%Lfi", &re, &im );
         *ldc = re + im * _Complex_I;
+        ldc = re + im * _Complex_I;
         return is;
 } // ?|?

src/libcfa/iterator

-              raf08051
+              r28e58fd
 trait iterator( otype iterator_type, otype elt_type ) {
         // point to the next element
 //      iterator_type ?++( iterator_type * );
         iterator_type ++?( iterator_type * );
         iterator_type --?( iterator_type * );
+//      iterator_type ?++( iterator_type & );
+        iterator_type ++?( iterator_type & );
+        iterator_type --?( iterator_type & );
         // can be tested for equality with other iterators
 …
         // dereference to get the pointed-at element
         lvalue elt_type *?( iterator_type );
+        elt_type & *?( iterator_type );
 };

src/libcfa/rational

-              raf08051
+              r28e58fd
 // Created On       : Wed Apr  6 17:56:25 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul  7 09:34:33 2017
 // Update Count     : 93
+// Last Modified On : Wed Aug 23 22:35:09 2017
+// Update Count     : 95
 //
 …
         int ?>?( T, T );
         int ?>=?( T, T );
         void ?{}( T *, zero_t );
         void ?{}( T *, one_t );
+        void ?{}( T &, zero_t );
+        void ?{}( T &, one_t );
         T +?( T );
         T -?( T );
 …
         T ?/?( T, T );
         T ?%?( T, T );
         T ?/=?( T *, T );
+        T ?/=?( T &, T );
         T abs( T );
 };
 …
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r );
+void ?{}( Rational(RationalImpl) & r );
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r, RationalImpl n );
+void ?{}( Rational(RationalImpl) & r, RationalImpl n );
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r, RationalImpl n, RationalImpl d );
+void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d );
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r, zero_t );
+void ?{}( Rational(RationalImpl) & r, zero_t );
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r, one_t );
+void ?{}( Rational(RationalImpl) & r, one_t );
 // numerator/denominator getter
 …
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 [ RationalImpl, RationalImpl ] ?=?( * [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
+[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src );
 // numerator/denominator setter
 …
 // I/O
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 forall( dtype istype | istream( istype ) | { istype * ?|?( istype *, RationalImpl * ); } )
 istype * ?|?( istype *, Rational(RationalImpl) * );
+forall( dtype istype | istream( istype ) | { istype * ?|?( istype *, RationalImpl & ); } )
+istype * ?|?( istype *, Rational(RationalImpl) & );
 forall( otype RationalImpl | arithmetic( RationalImpl ) )

src/libcfa/rational.c

-              raf08051
+              r28e58fd
 //
+//
 // 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.
 //
 // rational.c --
 //
+//
+// rational.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Wed Apr  6 17:54:28 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 16 18:35:36 2017
 // Update Count     : 150
 //
+// Last Modified On : Wed Aug 23 22:38:48 2017
+// Update Count     : 154
+//
 #include "rational"
 …
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 static RationalImpl simplify( RationalImpl * n, RationalImpl * d ) {
         if ( *d == (RationalImpl){0} ) {
+static RationalImpl simplify( RationalImpl & n, RationalImpl & d ) {
+        if ( d == (RationalImpl){0} ) {
                 serr | "Invalid rational number construction: denominator cannot be equal to 0." | endl;
                 exit( EXIT_FAILURE );
         } // exit
         if ( *d < (RationalImpl){0} ) { *d = -*d; *n = -*n; } // move sign to numerator
         return gcd( abs( *n ), *d );                                            // simplify
+        if ( d < (RationalImpl){0} ) { d = -d; n = -n; }        // move sign to numerator
+        return gcd( abs( n ), d );                                                      // simplify
 } // Rationalnumber::simplify
 …
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r ) {
+void ?{}( Rational(RationalImpl) & r ) {
         r{ (RationalImpl){0}, (RationalImpl){1} };
 } // rational
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r, RationalImpl n ) {
+void ?{}( Rational(RationalImpl) & r, RationalImpl n ) {
         r{ n, (RationalImpl){1} };
 } // rational
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 void ?{}( Rational(RationalImpl) * r, RationalImpl n, RationalImpl d ) {
         RationalImpl t = simplify( &n, &d );                            // simplify
         r->numerator = n / t;
         r->denominator = d / t;
+void ?{}( Rational(RationalImpl) & r, RationalImpl n, RationalImpl d ) {
+        RationalImpl t = simplify( n, d );                                      // simplify
+        r.numerator = n / t;
+        r.denominator = d / t;
 } // rational
 …
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 [ RationalImpl, RationalImpl ] ?=?( * [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) {
         return *dest = src.[ numerator, denominator ];
+[ RationalImpl, RationalImpl ] ?=?( & [ RationalImpl, RationalImpl ] dest, Rational(RationalImpl) src ) {
+        return dest = src.[ numerator, denominator ];
+}
 …
 RationalImpl denominator( Rational(RationalImpl) r, RationalImpl d ) {
         RationalImpl prev = r.denominator;
         RationalImpl t = simplify( &r.numerator, &d );                  // simplify
+        RationalImpl t = simplify( r.numerator, d );                    // simplify
         r.numerator = r.numerator / t;
         r.denominator = d / t;
 …
 forall( otype RationalImpl | arithmetic( RationalImpl ) )
 forall( dtype istype | istream( istype ) | { istype * ?|?( istype *, RationalImpl * ); } )
 istype * ?|?( istype * is, Rational(RationalImpl) * r ) {
+forall( dtype istype | istream( istype ) | { istype * ?|?( istype *, RationalImpl & ); } )
+istype * ?|?( istype * is, Rational(RationalImpl) & r ) {
         RationalImpl t;
         is | &(r->numerator) | &(r->denominator);
         t = simplify( &(r->numerator), &(r->denominator) );
         r->numerator /= t;
         r->denominator /= t;
+        is | r.numerator | r.denominator;
+        t = simplify( r.numerator, r.denominator );
+        r.numerator /= t;
+        r.denominator /= t;
         return is;
 } // ?|?

src/libcfa/stdlib

-              raf08051
+              r28e58fd
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug  7 11:19:07 2017
 // Update Count     : 223
+// Last Modified On : Wed Aug 23 20:29:47 2017
+// Update Count     : 224
 //
 …
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * new( Params p );
 forall( dtype T | { void ^?{}( T * ); } ) void delete( T * ptr );
 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } ) void delete( T * ptr, Params rest );
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * new( Params p );
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void delete( T * ptr );
+forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } ) void delete( T * ptr, Params rest );
 // allocation/deallocation and constructor/destructor, array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } ) T * anew( size_t dim, Params p );
 forall( dtype T | sized(T) | { void ^?{}( T * ); } ) void adelete( size_t dim, T arr[] );
 forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
 //---------------------------------------
 …
 double abs( double _Complex );
 long double abs( long double _Complex );
 forall( otype T | { void ?{}( T *, zero_t ); int ?<?( T, T ); T -?( T ); } )
+forall( otype T | { void ?{}( T &, zero_t ); int ?<?( T, T ); T -?( T ); } )
 T abs( T );
 …
 forall( otype T )
 void swap( T * t1, T * t2 );
+void swap( T & t1, T & t2 );
 // Local Variables: //

src/libcfa/stdlib.c

-              raf08051
+              r28e58fd
 // Created On       : Thu Jan 28 17:10:29 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Aug  8 17:31:13 2017
 // Update Count     : 291
+// Last Modified On : Wed Aug 23 20:30:44 2017
+// Update Count     : 292
 //
 …
         if ( nlen > olen ) {                                                            // larger ?
                 memset( nptr + olen, (int)fill, nlen - olen );  // initialize added storage
         } //
+        } //
     return (T *)nptr;
 } // alloc
 // allocation/deallocation and constructor/destructor, non-array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * new( Params p ) {
         return (malloc()){ p };                                                         // run constructor
+        return &(*malloc()){ p };                                                               // run constructor
 } // new
 forall( dtype T | { void ^?{}( T * ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); } )
 void delete( T * ptr ) {
         if ( ptr ) {                                                                            // ignore null
                 ^ptr{};                                                                                 // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
 } // delete
 forall( dtype T, ttype Params | { void ^?{}( T * ); void delete( Params ); } )
+forall( dtype T, ttype Params | sized(T) | { void ^?{}( T & ); void delete( Params ); } )
 void delete( T * ptr, Params rest ) {
         if ( ptr ) {                                                                            // ignore null
                 ^ptr{};                                                                                 // run destructor
+                ^(*ptr){};                                                                                      // run destructor
                 free( ptr );
         } // if
 …
 // allocation/deallocation and constructor/destructor, array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T *, Params ); } )
+forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } )
 T * anew( size_t dim, Params p ) {
         T *arr = alloc( dim );
         for ( unsigned int i = 0; i < dim; i += 1 ) {
                 (&arr[i]){ p };                                                                 // run constructor
+                (arr[i]){ p };                                                                  // run constructor
         } // for
         return arr;
 } // anew
 forall( dtype T | sized(T) | { void ^?{}( T * ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); } )
 void adelete( size_t dim, T arr[] ) {
         if ( arr ) {                                                                            // ignore null
                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
                         ^(&arr[i]){};                                                           // run destructor
+                        ^(arr[i]){};                                                            // run destructor
                 } // for
                 free( arr );
 …
 } // adelete
 forall( dtype T | sized(T) | { void ^?{}( T * ); }, ttype Params | { void adelete( Params ); } )
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
 void adelete( size_t dim, T arr[], Params rest ) {
         if ( arr ) {                                                                            // ignore null
                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
                         ^(&arr[i]){};                                                           // run destructor
+                        ^(arr[i]){};                                                            // run destructor
                 } // for
                 free( arr );
 …
 forall( otype T )
 void swap( T * t1, T * t2 ) {
         T temp = *t1;
         *t1 = *t2;
         *t2 = temp;
+void swap( T & t1, T & t2 ) {
+        T temp = t1;
+        t1 = t2;
+        t2 = temp;
 } // swap

src/prelude/builtins.c

-              raf08051
+              r28e58fd
 } // ?\?
 static inline forall( otype T | { void ?{}( T * this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
+static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
 double ?\?( T x, signed long int y ) {
     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
 …
 } // ?\?
 static inline long int ?\=?( long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
 static inline unsigned long int ?\=?( unsigned long int * x, unsigned long int y ) { *x = *x \ y; return *x; }
 static inline int ?\=?( int * x, unsigned long int y ) { *x = *x \ y; return *x; }
 static inline unsigned int ?\=?( unsigned int * x, unsigned long int y ) { *x = *x \ y; return *x; }
+static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
 // Local Variables: //

src/prelude/prelude.cf

-              raf08051
+              r28e58fd
 // ------------------------------------------------------------
 _Bool                   ?++( _Bool * ),                         ?++( volatile _Bool * );
 _Bool                   ?--( _Bool * ),                         ?--( volatile _Bool * );
 unsigned char           ?++( unsigned char * ),                 ?++( volatile unsigned char * );
 signed int              ?++( signed int * ),                    ?++( volatile signed int * );
 signed int              ?--( signed int * ),                    ?--( volatile signed int * );
 unsigned int            ?++( unsigned int * ),                  ?++( volatile unsigned int * );
 unsigned int            ?--( unsigned int * ),                  ?--( volatile unsigned int * );
 signed long int         ?++( signed long int * ),               ?++( volatile signed long int * );
 signed long int         ?--( signed long int * ),               ?--( volatile signed long int * );
 unsigned long int       ?++( unsigned long int * ),             ?++( volatile unsigned long int * );
 unsigned long int       ?--( unsigned long int * ),             ?--( volatile unsigned long int * );
 signed long long int    ?++( signed long long int * ),          ?++( volatile signed long long int * );
 signed long long int    ?--( signed long long int * ),          ?--( volatile signed long long int * );
 unsigned long long int  ?++( unsigned long long int * ),        ?++( volatile unsigned long long int * );
 unsigned long long int  ?--( unsigned long long int * ),        ?--( volatile unsigned long long int * );
 float                   ?++( float * ),                         ?++( volatile float * );
 float                   ?--( float * ),                         ?--( volatile float * );
 double                  ?++( double * ),                        ?++( volatile double * );
 double                  ?--( double * ),                        ?--( volatile double * );
 long double             ?++( long double * ),                   ?++( volatile long double * );
 long double             ?--( long double * ),                   ?--( volatile long double * );
 float _Complex          ?++( float _Complex * ),                ?++( volatile float _Complex * );
 float _Complex          ?--( float _Complex * ),                ?--( volatile float _Complex * );
 double _Complex         ?++( double _Complex * ),               ?++( volatile double _Complex * );
 double _Complex         ?--( double _Complex * ),               ?--( volatile double _Complex * );
 long double _Complex    ?++( long double _Complex * ),          ?++( volatile long double _Complex * );
 long double _Complex    ?--( long double _Complex * ),          ?--( volatile long double _Complex * );
 forall( dtype T | sized(T) ) T *                         ?++(                T ** );
 forall( dtype T | sized(T) ) const T *           ?++( const          T ** );
 forall( dtype T | sized(T) ) volatile T *                ?++(       volatile T ** );
 forall( dtype T | sized(T) ) const volatile T *  ?++( const volatile T ** );
 forall( dtype T | sized(T) ) T *                         ?--(                T ** );
 forall( dtype T | sized(T) ) const T *           ?--( const          T ** );
 forall( dtype T | sized(T) ) volatile T *                ?--(       volatile T ** );
 forall( dtype T | sized(T) ) const volatile T *  ?--( const volatile T ** );
 forall( dtype T | sized(T) ) lvalue T            ?[?](                T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) const lvalue T      ?[?]( const          T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) volatile lvalue T   ?[?](       volatile T *,          ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile lvalue T ?[?]( const volatile T *,      ptrdiff_t );
 forall( dtype T | sized(T) ) lvalue T            ?[?](          ptrdiff_t,                T * );
 forall( dtype T | sized(T) ) const lvalue T      ?[?](          ptrdiff_t, const          T * );
 forall( dtype T | sized(T) ) volatile lvalue T   ?[?](          ptrdiff_t,       volatile T * );
 forall( dtype T | sized(T) ) const volatile lvalue T ?[?](              ptrdiff_t, const volatile T * );
+_Bool                   ?++( _Bool & ),                         ?++( volatile _Bool & );
+_Bool                   ?--( _Bool & ),                         ?--( volatile _Bool & );
+unsigned char           ?++( unsigned char & ),                 ?++( volatile unsigned char & );
+signed int              ?++( signed int & ),                    ?++( volatile signed int & );
+signed int              ?--( signed int & ),                    ?--( volatile signed int & );
+unsigned int            ?++( unsigned int & ),                  ?++( volatile unsigned int & );
+unsigned int            ?--( unsigned int & ),                  ?--( volatile unsigned int & );
+signed long int         ?++( signed long int & ),               ?++( volatile signed long int & );
+signed long int         ?--( signed long int & ),               ?--( volatile signed long int & );
+unsigned long int       ?++( unsigned long int & ),             ?++( volatile unsigned long int & );
+unsigned long int       ?--( unsigned long int & ),             ?--( volatile unsigned long int & );
+signed long long int    ?++( signed long long int & ),          ?++( volatile signed long long int & );
+signed long long int    ?--( signed long long int & ),          ?--( volatile signed long long int & );
+unsigned long long int  ?++( unsigned long long int & ),        ?++( volatile unsigned long long int & );
+unsigned long long int  ?--( unsigned long long int & ),        ?--( volatile unsigned long long int & );
+float                   ?++( float & ),                         ?++( volatile float & );
+float                   ?--( float & ),                         ?--( volatile float & );
+double                  ?++( double & ),                        ?++( volatile double & );
+double                  ?--( double & ),                        ?--( volatile double & );
+long double             ?++( long double & ),                   ?++( volatile long double & );
+long double             ?--( long double & ),                   ?--( volatile long double & );
+float _Complex          ?++( float _Complex & ),                ?++( volatile float _Complex & );
+float _Complex          ?--( float _Complex & ),                ?--( volatile float _Complex & );
+double _Complex         ?++( double _Complex & ),               ?++( volatile double _Complex & );
+double _Complex         ?--( double _Complex & ),               ?--( volatile double _Complex & );
+long double _Complex    ?++( long double _Complex & ),          ?++( volatile long double _Complex & );
+long double _Complex    ?--( long double _Complex & ),          ?--( volatile long double _Complex & );
+forall( dtype T | sized(T) ) T *                         ?++(                T *& );
+forall( dtype T | sized(T) ) const T *           ?++( const          T *& );
+forall( dtype T | sized(T) ) volatile T *                ?++(       volatile T *& );
+forall( dtype T | sized(T) ) const volatile T *  ?++( const volatile T *& );
+forall( dtype T | sized(T) ) T *                         ?--(                T *& );
+forall( dtype T | sized(T) ) const T *           ?--( const          T *& );
+forall( dtype T | sized(T) ) volatile T *                ?--(       volatile T *& );
+forall( dtype T | sized(T) ) const volatile T *  ?--( const volatile T *& );
+forall( dtype T | sized(T) ) T &                 ?[?](                T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) const T &   ?[?]( const          T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T &        ?[?](       volatile T *,          ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T & ?[?]( const volatile T *,           ptrdiff_t );
+forall( dtype T | sized(T) ) T &                 ?[?](          ptrdiff_t,                T * );
+forall( dtype T | sized(T) ) const T &   ?[?](          ptrdiff_t, const          T * );
+forall( dtype T | sized(T) ) volatile T &        ?[?](          ptrdiff_t,       volatile T * );
+forall( dtype T | sized(T) ) const volatile T & ?[?](           ptrdiff_t, const volatile T * );
 // ------------------------------------------------------------
 …
 // ------------------------------------------------------------
 _Bool                   ++?( _Bool * ),                         --?( _Bool * );
 signed int              ++?( signed int * ),                    --?( signed int * );
 unsigned int            ++?( unsigned int * ),                  --?( unsigned int * );
 signed long int         ++?( signed long int * ),               --?( signed long int * );
 unsigned long int       ++?( unsigned long int * ),             --?( unsigned long int * );
 signed long long int    ++?( signed long long int * ),          --?( signed long long int * );
 unsigned long long int  ++?( unsigned long long int * ),        --?( unsigned long long int * );
 float                   ++?( float * ),                         --?( float * );
 double                  ++?( double * ),                        --?( double * );
 long double             ++?( long double * ),                   --?( long double * );
 float _Complex          ++?( float _Complex * ),                --?( float _Complex * );
 double _Complex         ++?( double _Complex * ),               --?( double _Complex * );
 long double _Complex    ++?( long double _Complex * ),          --?( long double _Complex * );
 forall( dtype T | sized(T) ) T *                         ++?(                T ** );
 forall( dtype T | sized(T) ) const T *           ++?( const          T ** );
 forall( dtype T | sized(T) ) volatile T *                ++?(       volatile T ** );
 forall( dtype T | sized(T) ) const volatile T *  ++?( const volatile T ** );
 forall( dtype T | sized(T) ) T *                         --?(                T ** );
 forall( dtype T | sized(T) ) const T *           --?( const          T ** );
 forall( dtype T | sized(T) ) volatile T *                --?(       volatile T ** );
 forall( dtype T | sized(T) ) const volatile T *  --?( const volatile T ** );
 forall( dtype T | sized(T) ) lvalue T            *?(                 T * );
 forall( dtype T | sized(T) ) const lvalue T              *?( const           T * );
 forall( dtype T | sized(T) ) volatile lvalue T   *?(       volatile  T * );
 forall( dtype T | sized(T) ) const volatile lvalue T *?( const volatile  T * );
 forall( ftype FT ) lvalue FT             *?( FT * );
+_Bool                   ++?( _Bool & ),                         --?( _Bool & );
+signed int              ++?( signed int & ),                    --?( signed int & );
+unsigned int            ++?( unsigned int & ),                  --?( unsigned int & );
+signed long int         ++?( signed long int & ),               --?( signed long int & );
+unsigned long int       ++?( unsigned long int & ),             --?( unsigned long int & );
+signed long long int    ++?( signed long long int & ),          --?( signed long long int & );
+unsigned long long int  ++?( unsigned long long int & ),        --?( unsigned long long int & );
+float                   ++?( float & ),                         --?( float & );
+double                  ++?( double & ),                        --?( double & );
+long double             ++?( long double & ),                   --?( long double & );
+float _Complex          ++?( float _Complex & ),                --?( float _Complex & );
+double _Complex         ++?( double _Complex & ),               --?( double _Complex & );
+long double _Complex    ++?( long double _Complex & ),          --?( long double _Complex & );
+forall( dtype T | sized(T) ) T *                         ++?(                T *& );
+forall( dtype T | sized(T) ) const T *           ++?( const          T *& );
+forall( dtype T | sized(T) ) volatile T *                ++?(       volatile T *& );
+forall( dtype T | sized(T) ) const volatile T *  ++?( const volatile T *& );
+forall( dtype T | sized(T) ) T *                         --?(                T *& );
+forall( dtype T | sized(T) ) const T *           --?( const          T *& );
+forall( dtype T | sized(T) ) volatile T *                --?(       volatile T *& );
+forall( dtype T | sized(T) ) const volatile T *  --?( const volatile T *& );
+forall( dtype T | sized(T) ) T &                 *?(                 T * );
+forall( dtype T | sized(T) ) const T &           *?( const           T * );
+forall( dtype T | sized(T) ) volatile T &        *?(       volatile  T * );
+forall( dtype T | sized(T) ) const volatile T & *?( const volatile  T * );
+forall( ftype FT ) FT &          *?( FT * );
 _Bool                   +?( _Bool ),                    -?( _Bool ),                    ~?( _Bool );
 …
 // ------------------------------------------------------------
 forall( ftype FT ) FT *                 ?=?( FT **, FT * );
 forall( ftype FT ) FT *                 ?=?( FT * volatile *, FT * );
 forall( dtype DT ) DT *                 ?=?(                 DT *          *,                   DT * );
 forall( dtype DT ) DT *                 ?=?(                 DT * volatile *,                   DT * );
 forall( dtype DT ) const DT *           ?=?( const           DT *          *,                   DT * );
 forall( dtype DT ) const DT *           ?=?( const           DT * volatile *,                   DT * );
 forall( dtype DT ) const DT *           ?=?( const           DT *          *, const             DT * );
 forall( dtype DT ) const DT *           ?=?( const           DT * volatile *, const             DT * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          *,                   DT * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile *,                   DT * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          *,       volatile    DT * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile *,       volatile    DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *,                   DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *,                   DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *, const             DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *, const             DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *,       volatile    DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *,       volatile    DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *, const volatile    DT * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *, const volatile    DT * );
 forall( dtype DT ) DT *                 ?=?(                 DT *          *,                   void * );
 forall( dtype DT ) DT *                 ?=?(                 DT * volatile *,                   void * );
 forall( dtype DT ) const DT *           ?=?( const           DT *          *,                   void * );
 forall( dtype DT ) const DT *           ?=?( const           DT * volatile *,                   void * );
 forall( dtype DT ) const DT *           ?=?( const           DT *          *, const             void * );
 forall( dtype DT ) const DT *           ?=?( const           DT * volatile *, const             void * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          *,                   void * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile *,                   void * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          *,       volatile    void * );
 forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile *,       volatile    void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *,                   void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *,                   void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *, const             void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *, const             void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *,       volatile    void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *,       volatile    void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          *, const volatile    void * );
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile *, const volatile    void * );
 forall( dtype DT ) void *                ?=?(                void *          *,                 DT * );
 forall( dtype DT ) void *                ?=?(                void * volatile *,                 DT * );
 forall( dtype DT ) const void *          ?=?( const          void *          *,                 DT * );
 forall( dtype DT ) const void *          ?=?( const          void * volatile *,                 DT * );
 forall( dtype DT ) const void *          ?=?( const          void *          *, const           DT * );
 forall( dtype DT ) const void *          ?=?( const          void * volatile *, const           DT * );
 forall( dtype DT ) volatile void *       ?=?(       volatile void *          *,                 DT * );
 forall( dtype DT ) volatile void *       ?=?(       volatile void * volatile *,                 DT * );
 forall( dtype DT ) volatile void *       ?=?(       volatile void *          *,       volatile  DT * );
 forall( dtype DT ) volatile void *       ?=?(       volatile void * volatile *,       volatile  DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void *          *,                 DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *,                 DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void *          *, const           DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, const           DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void *          *,       volatile  DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *,       volatile  DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void *          *, const volatile  DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile *, const volatile  DT * );
 void *                  ?=?(                void *          *,                void * );
 void *                  ?=?(                void * volatile *,                void * );
 const void *            ?=?( const          void *          *,                void * );
 const void *            ?=?( const          void * volatile *,                void * );
 const void *            ?=?( const          void *          *, const          void * );
 const void *            ?=?( const          void * volatile *, const          void * );
 volatile void *         ?=?(       volatile void *          *,                void * );
 volatile void *         ?=?(       volatile void * volatile *,                void * );
 volatile void *         ?=?(       volatile void *          *,       volatile void * );
 volatile void *         ?=?(       volatile void * volatile *,       volatile void * );
 const volatile void *   ?=?( const volatile void *          *,                void * );
 const volatile void *   ?=?( const volatile void * volatile *,                void * );
 const volatile void *   ?=?( const volatile void *          *, const          void * );
 const volatile void *   ?=?( const volatile void * volatile *, const          void * );
 const volatile void *   ?=?( const volatile void *          *,       volatile void * );
 const volatile void *   ?=?( const volatile void * volatile *,       volatile void * );
 const volatile void *   ?=?( const volatile void *          *, const volatile void * );
 const volatile void *   ?=?( const volatile void * volatile *, const volatile void * );
 // //forall( dtype DT ) DT *                    ?=?(                DT *          *, zero_t );
 // //forall( dtype DT ) DT *                    ?=?(                DT * volatile *, zero_t );
 // forall( dtype DT ) const DT *                ?=?( const          DT *          *, zero_t );
 // forall( dtype DT ) const DT *                ?=?( const          DT * volatile *, zero_t );
 // //forall( dtype DT ) volatile DT *   ?=?( volatile       DT *          *, zero_t );
 // //forall( dtype DT ) volatile DT *   ?=?( volatile       DT * volatile *,  );
 // forall( dtype DT ) const volatile DT *       ?=?( const volatile DT *          *, zero_t );
 // forall( dtype DT ) const volatile DT *       ?=?( const volatile DT * volatile *, zero_t );
 // forall( ftype FT ) FT *                      ?=?( FT *          *, zero_t );
 // forall( ftype FT ) FT *                      ?=?( FT * volatile *, zero_t );
 forall( dtype T | sized(T) ) T *                        ?+=?(                T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?+=?(                T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?+=?( const          T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?+=?( const          T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?+=?(       volatile T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?+=?(       volatile T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?-=?(                T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) T *                        ?-=?(                T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?-=?( const          T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) const T *          ?-=?( const          T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?-=?(       volatile T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) volatile T *               ?-=?(       volatile T * volatile *, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T *          *, ptrdiff_t );
 forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile *, ptrdiff_t );
 _Bool                   ?=?( _Bool *, _Bool ),                                  ?=?( volatile _Bool *, _Bool );
 char                    ?=?( char *, char ),                                    ?=?( volatile char *, char );
 char signed             ?=?( char signed *, char signed ),                      ?=?( volatile char signed *, char signed );
 char unsigned           ?=?( char unsigned *, char unsigned ),                  ?=?( volatile char unsigned *, char unsigned );
 int short               ?=?( int short *, int short ),                          ?=?( volatile int short *, int short );
 int short unsigned      ?=?( int short unsigned *, int short unsigned ),        ?=?( volatile int short unsigned *, int short unsigned );
 signed int              ?=?( signed int *, signed int ),                        ?=?( volatile signed int *, signed int );
 unsigned int            ?=?( unsigned *, unsigned ),                            ?=?( volatile unsigned *, unsigned );
 signed long int         ?=?( signed long int *, signed long int ),              ?=?( volatile signed long int *, signed long int );
 unsigned long int       ?=?( unsigned long int *, unsigned long int ),          ?=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?=?( signed long long int *, signed long long int ),    ?=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?=?( unsigned long long int *, unsigned long long int ), ?=?( volatile unsigned long long int *, unsigned long long int );
 zero_t          ?=?( zero_t *, zero_t );
 one_t                   ?=?( one_t *, one_t );
 _Bool                   ?*=?( _Bool *, _Bool ),                                 ?*=?( volatile _Bool *, _Bool );
 char                    ?*=?( char *, char ),                                   ?*=?( volatile char *, char );
 char signed             ?*=?( char signed *, char signed ),                     ?*=?( volatile char signed *, char signed );
 char unsigned           ?*=?( char unsigned *, char unsigned ),                 ?*=?( volatile char unsigned *, char unsigned );
 int short               ?*=?( int short *, int short ),                         ?*=?( volatile int short *, int short );
 int short unsigned      ?*=?( int short unsigned *, int short unsigned ),       ?*=?( volatile int short unsigned *, int short unsigned );
 signed int              ?*=?( signed int *, signed int ),                       ?*=?( volatile signed int *, signed int );
 unsigned int            ?*=?( unsigned *, unsigned ),                           ?*=?( volatile unsigned *, unsigned );
 signed long int         ?*=?( signed long int *, signed long int ),             ?*=?( volatile signed long int *, signed long int );
 unsigned long int       ?*=?( unsigned long int *, unsigned long int ),         ?*=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?*=?( signed long long int *, signed long long int ),   ?*=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?*=?( unsigned long long int *, unsigned long long int ), ?*=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?/=?( _Bool *, _Bool ),                                 ?/=?( volatile _Bool *, _Bool );
 char                    ?/=?( char *, char ),                                   ?/=?( volatile char *, char );
 char signed             ?/=?( char signed *, char signed ),                     ?/=?( volatile char signed *, char signed );
 char unsigned           ?/=?( char unsigned *, char unsigned ),                 ?/=?( volatile char unsigned *, char unsigned );
 int short               ?/=?( int short *, int short ),                         ?/=?( volatile int short *, int short );
 int short unsigned      ?/=?( int short unsigned *, int short unsigned ),       ?/=?( volatile int short unsigned *, int short unsigned );
 signed int              ?/=?( signed int *, signed int ),                       ?/=?( volatile signed int *, signed int );
 unsigned int            ?/=?( unsigned *, unsigned ),                           ?/=?( volatile unsigned *, unsigned );
 signed long int         ?/=?( signed long int *, signed long int ),             ?/=?( volatile signed long int *, signed long int );
 unsigned long int       ?/=?( unsigned long int *, unsigned long int ),         ?/=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?/=?( signed long long int *, signed long long int ),   ?/=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?/=?( unsigned long long int *, unsigned long long int ), ?/=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?%=?( _Bool *, _Bool ),                                 ?%=?( volatile _Bool *, _Bool );
 char                    ?%=?( char *, char ),                                   ?%=?( volatile char *, char );
 char signed             ?%=?( char signed *, char signed ),                     ?%=?( volatile char signed *, char signed );
 char unsigned           ?%=?( char unsigned *, char unsigned ),                 ?%=?( volatile char unsigned *, char unsigned );
 int short               ?%=?( int short *, int short ),                         ?%=?( volatile int short *, int short );
 int short unsigned      ?%=?( int short unsigned *, int short unsigned ),       ?%=?( volatile int short unsigned *, int short unsigned );
 signed int              ?%=?( signed int *, signed int ),                       ?%=?( volatile signed int *, signed int );
 unsigned int            ?%=?( unsigned *, unsigned ),                           ?%=?( volatile unsigned *, unsigned );
 signed long int         ?%=?( signed long int *, signed long int ),             ?%=?( volatile signed long int *, signed long int );
 unsigned long int       ?%=?( unsigned long int *, unsigned long int ),         ?%=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?%=?( signed long long int *, signed long long int ),   ?%=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?%=?( unsigned long long int *, unsigned long long int ), ?%=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?+=?( _Bool *, _Bool ),                                 ?+=?( volatile _Bool *, _Bool );
 char                    ?+=?( char *, char ),                                   ?+=?( volatile char *, char );
 char signed             ?+=?( char signed *, char signed ),                     ?+=?( volatile char signed *, char signed );
 char unsigned           ?+=?( char unsigned *, char unsigned ),                 ?+=?( volatile char unsigned *, char unsigned );
 int short               ?+=?( int short *, int short ),                         ?+=?( volatile int short *, int short );
 int short unsigned      ?+=?( int short unsigned *, int short unsigned ),       ?+=?( volatile int short unsigned *, int short unsigned );
 signed int              ?+=?( signed int *, signed int ),                       ?+=?( volatile signed int *, signed int );
 unsigned int            ?+=?( unsigned *, unsigned ),                           ?+=?( volatile unsigned *, unsigned );
 signed long int         ?+=?( signed long int *, signed long int ),             ?+=?( volatile signed long int *, signed long int );
 unsigned long int       ?+=?( unsigned long int *, unsigned long int ),         ?+=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?+=?( signed long long int *, signed long long int ),   ?+=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?+=?( unsigned long long int *, unsigned long long int ), ?+=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?-=?( _Bool *, _Bool ),                                 ?-=?( volatile _Bool *, _Bool );
 char                    ?-=?( char *, char ),                                   ?-=?( volatile char *, char );
 char signed             ?-=?( char signed *, char signed ),                     ?-=?( volatile char signed *, char signed );
 char unsigned           ?-=?( char unsigned *, char unsigned ),                 ?-=?( volatile char unsigned *, char unsigned );
 int short               ?-=?( int short *, int short ),                         ?-=?( volatile int short *, int short );
 int short unsigned      ?-=?( int short unsigned *, int short unsigned ),       ?-=?( volatile int short unsigned *, int short unsigned );
 signed int              ?-=?( signed int *, signed int ),                       ?-=?( volatile signed int *, signed int );
 unsigned int            ?-=?( unsigned *, unsigned ),                           ?-=?( volatile unsigned *, unsigned );
 signed long int         ?-=?( signed long int *, signed long int ),             ?-=?( volatile signed long int *, signed long int );
 unsigned long int       ?-=?( unsigned long int *, unsigned long int ),         ?-=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?-=?( signed long long int *, signed long long int ),   ?-=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?-=?( unsigned long long int *, unsigned long long int ), ?-=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?<<=?( _Bool *, _Bool ),                                ?<<=?( volatile _Bool *, _Bool );
 char                    ?<<=?( char *, char ),                                  ?<<=?( volatile char *, char );
 char signed             ?<<=?( char signed *, char signed ),                    ?<<=?( volatile char signed *, char signed );
 char unsigned           ?<<=?( char unsigned *, char unsigned ),                ?<<=?( volatile char unsigned *, char unsigned );
 int short               ?<<=?( int short *, int short ),                        ?<<=?( volatile int short *, int short );
 int short unsigned      ?<<=?( int short unsigned *, int short unsigned ),      ?<<=?( volatile int short unsigned *, int short unsigned );
 signed int              ?<<=?( signed int *, signed int ),                      ?<<=?( volatile signed int *, signed int );
 unsigned int            ?<<=?( unsigned *, unsigned ),                          ?<<=?( volatile unsigned *, unsigned );
 signed long int         ?<<=?( signed long int *, signed long int ),            ?<<=?( volatile signed long int *, signed long int );
 unsigned long int       ?<<=?( unsigned long int *, unsigned long int ),        ?<<=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?<<=?( signed long long int *, signed long long int ),  ?<<=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?<<=?( unsigned long long int *, unsigned long long int ), ?<<=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?>>=?( _Bool *, _Bool ),                                ?>>=?( volatile _Bool *, _Bool );
 char                    ?>>=?( char *, char ),                                  ?>>=?( volatile char *, char );
 char signed             ?>>=?( char signed *, char signed ),                    ?>>=?( volatile char signed *, char signed );
 char unsigned           ?>>=?( char unsigned *, char unsigned ),                ?>>=?( volatile char unsigned *, char unsigned );
 int short               ?>>=?( int short *, int short ),                        ?>>=?( volatile int short *, int short );
 int short unsigned      ?>>=?( int short unsigned *, int short unsigned ),      ?>>=?( volatile int short unsigned *, int short unsigned );
 signed int              ?>>=?( signed int *, signed int ),                      ?>>=?( volatile signed int *, signed int );
 unsigned int            ?>>=?( unsigned *, unsigned ),                          ?>>=?( volatile unsigned *, unsigned );
 signed long int         ?>>=?( signed long int *, signed long int ),            ?>>=?( volatile signed long int *, signed long int );
 unsigned long int       ?>>=?( unsigned long int *, unsigned long int ),        ?>>=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?>>=?( signed long long int *, signed long long int ),  ?>>=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?>>=?( unsigned long long int *, unsigned long long int ), ?>>=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?&=?( _Bool *, _Bool ),                                 ?&=?( volatile _Bool *, _Bool );
 char                    ?&=?( char *, char ),                                   ?&=?( volatile char *, char );
 char signed             ?&=?( char signed *, char signed ),                     ?&=?( volatile char signed *, char signed );
 char unsigned           ?&=?( char unsigned *, char unsigned ),                 ?&=?( volatile char unsigned *, char unsigned );
 int short               ?&=?( int short *, int short ),                         ?&=?( volatile int short *, int short );
 int short unsigned      ?&=?( int short unsigned *, int short unsigned ),       ?&=?( volatile int short unsigned *, int short unsigned );
 signed int              ?&=?( signed int *, signed int ),                       ?&=?( volatile signed int *, signed int );
 unsigned int            ?&=?( unsigned *, unsigned ),                           ?&=?( volatile unsigned *, unsigned );
 signed long int         ?&=?( signed long int *, signed long int ),             ?&=?( volatile signed long int *, signed long int );
 unsigned long int       ?&=?( unsigned long int *, unsigned long int ),         ?&=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?&=?( signed long long int *, signed long long int ),   ?&=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?&=?( unsigned long long int *, unsigned long long int ), ?&=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?|=?( _Bool *, _Bool ),                                 ?|=?( volatile _Bool *, _Bool );
 char                    ?|=?( char *, char ),                                   ?|=?( volatile char *, char );
 char signed             ?|=?( char signed *, char signed ),                     ?|=?( volatile char signed *, char signed );
 char unsigned           ?|=?( char unsigned *, char unsigned ),                 ?|=?( volatile char unsigned *, char unsigned );
 int short               ?|=?( int short *, int short ),                         ?|=?( volatile int short *, int short );
 int short unsigned      ?|=?( int short unsigned *, int short unsigned ),       ?|=?( volatile int short unsigned *, int short unsigned );
 signed int              ?|=?( signed int *, signed int ),                       ?|=?( volatile signed int *, signed int );
 unsigned int            ?|=?( unsigned *, unsigned ),                           ?|=?( volatile unsigned *, unsigned );
 signed long int         ?|=?( signed long int *, signed long int ),             ?|=?( volatile signed long int *, signed long int );
 unsigned long int       ?|=?( unsigned long int *, unsigned long int ),         ?|=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?|=?( signed long long int *, signed long long int ),   ?|=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?|=?( unsigned long long int *, unsigned long long int ), ?|=?( volatile unsigned long long int *, unsigned long long int );
 _Bool                   ?^=?( _Bool *, _Bool ),                                 ?^=?( volatile _Bool *, _Bool );
 char                    ?^=?( char *, char ),                                   ?^=?( volatile char *, char );
 char signed             ?^=?( char signed *, char signed ),                     ?^=?( volatile char signed *, char signed );
 char unsigned           ?^=?( char unsigned *, char unsigned ),                 ?^=?( volatile char unsigned *, char unsigned );
 int short               ?^=?( int short *, int short ),                         ?^=?( volatile int short *, int short );
 int short unsigned      ?^=?( int short unsigned *, int short unsigned ),       ?^=?( volatile int short unsigned *, int short unsigned );
 signed int              ?^=?( signed int *, signed int ),                       ?^=?( volatile signed int *, signed int );
 unsigned int            ?^=?( unsigned *, unsigned ),                           ?^=?( volatile unsigned *, unsigned );
 signed long int         ?^=?( signed long int *, signed long int ),             ?^=?( volatile signed long int *, signed long int );
 unsigned long int       ?^=?( unsigned long int *, unsigned long int ),         ?^=?( volatile unsigned long int *, unsigned long int );
 signed long long int    ?^=?( signed long long int *, signed long long int ),   ?^=?( volatile signed long long int *, signed long long int );
 unsigned long long int  ?^=?( unsigned long long int *, unsigned long long int ), ?^=?( volatile unsigned long long int *, unsigned long long int );
 float                   ?=?(  float *, float ), ?=?(  volatile float *, float ),
                         ?*=?( float *, float ), ?*=?( volatile float *, float ),
                         ?/=?( float *, float ), ?/=?( volatile float *, float ),
                         ?+=?( float *, float ), ?+=?( volatile float *, float ),
                         ?-=?( float *, float ), ?-=?( volatile float *, float );
 double                  ?=?(  double *, double ), ?=?(  volatile double *, double ),
                         ?*=?( double *, double ), ?*=?( volatile double *, double ),
                         ?/=?( double *, double ), ?/=?( volatile double *, double ),
                         ?+=?( double *, double ), ?+=?( volatile double *, double ),
                         ?-=?( double *, double ), ?-=?( volatile double *, double );
 long double             ?=?(  long double *, long double ), ?=?(  volatile long double *, long double ),
                         ?*=?( long double *, long double ), ?*=?( volatile long double *, long double ),
                         ?/=?( long double *, long double ), ?/=?( volatile long double *, long double ),
                         ?+=?( long double *, long double ), ?+=?( volatile long double *, long double ),
                         ?-=?( long double *, long double ), ?-=?( volatile long double *, long double );
 float _Complex          ?=?(  float _Complex *, float _Complex ), ?=?(  volatile float _Complex *, float _Complex ),
                         ?*=?( float _Complex *, float _Complex ), ?*=?( volatile float _Complex *, float _Complex ),
                         ?/=?( float _Complex *, float _Complex ), ?/=?( volatile float _Complex *, float _Complex ),
                         ?+=?( float _Complex *, float _Complex ), ?+=?( volatile float _Complex *, float _Complex ),
                         ?-=?( float _Complex *, float _Complex ), ?-=?( volatile float _Complex *, float _Complex );
 double _Complex         ?=?(  double _Complex *, double _Complex ), ?=?(  volatile double _Complex *, double _Complex ),
                         ?*=?( double _Complex *, double _Complex ), ?*=?( volatile double _Complex *, double _Complex ),
                         ?/=?( double _Complex *, double _Complex ), ?/=?( volatile double _Complex *, double _Complex ),
                         ?+=?( double _Complex *, double _Complex ), ?+=?( volatile double _Complex *, double _Complex ),
                         ?-=?( double _Complex *, double _Complex ), ?-=?( volatile double _Complex *, double _Complex );
 long double _Complex    ?=?(  long double _Complex *, long double _Complex ), ?=?(  volatile long double _Complex *, long double _Complex ),
                         ?*=?( long double _Complex *, long double _Complex ), ?*=?( volatile long double _Complex *, long double _Complex ),
                         ?/=?( long double _Complex *, long double _Complex ), ?/=?( volatile long double _Complex *, long double _Complex ),
                         ?+=?( long double _Complex *, long double _Complex ), ?+=?( volatile long double _Complex *, long double _Complex ),
                         ?-=?( long double _Complex *, long double _Complex ), ?-=?( volatile long double _Complex *, long double _Complex );
+forall( ftype FT ) FT *                 ?=?( FT *&, FT * );
+forall( ftype FT ) FT *                 ?=?( FT * volatile &, FT * );
+forall( dtype DT ) DT *                 ?=?(                 DT *          &,                   DT * );
+forall( dtype DT ) DT *                 ?=?(                 DT * volatile &,                   DT * );
+forall( dtype DT ) const DT *           ?=?( const           DT *          &,                   DT * );
+forall( dtype DT ) const DT *           ?=?( const           DT * volatile &,                   DT * );
+forall( dtype DT ) const DT *           ?=?( const           DT *          &, const             DT * );
+forall( dtype DT ) const DT *           ?=?( const           DT * volatile &, const             DT * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,                   DT * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,                   DT * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,       volatile    DT * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,       volatile    DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,                   DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,                   DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const             DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const             DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,       volatile    DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,       volatile    DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const volatile    DT * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile    DT * );
+forall( dtype DT ) DT *                 ?=?(                 DT *          &,                   void * );
+forall( dtype DT ) DT *                 ?=?(                 DT * volatile &,                   void * );
+forall( dtype DT ) const DT *           ?=?( const           DT *          &,                   void * );
+forall( dtype DT ) const DT *           ?=?( const           DT * volatile &,                   void * );
+forall( dtype DT ) const DT *           ?=?( const           DT *          &, const             void * );
+forall( dtype DT ) const DT *           ?=?( const           DT * volatile &, const             void * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,                   void * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,                   void * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,       volatile    void * );
+forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,       volatile    void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,                   void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,                   void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const             void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const             void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,       volatile    void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,       volatile    void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const volatile    void * );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile    void * );
+forall( dtype DT ) void *                ?=?(                void *          &,                 DT * );
+forall( dtype DT ) void *                ?=?(                void * volatile &,                 DT * );
+forall( dtype DT ) const void *          ?=?( const          void *          &,                 DT * );
+forall( dtype DT ) const void *          ?=?( const          void * volatile &,                 DT * );
+forall( dtype DT ) const void *          ?=?( const          void *          &, const           DT * );
+forall( dtype DT ) const void *          ?=?( const          void * volatile &, const           DT * );
+forall( dtype DT ) volatile void *       ?=?(       volatile void *          &,                 DT * );
+forall( dtype DT ) volatile void *       ?=?(       volatile void * volatile &,                 DT * );
+forall( dtype DT ) volatile void *       ?=?(       volatile void *          &,       volatile  DT * );
+forall( dtype DT ) volatile void *       ?=?(       volatile void * volatile &,       volatile  DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *          &,                 DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &,                 DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *          &, const           DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const           DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *          &,       volatile  DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &,       volatile  DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void *          &, const volatile  DT * );
+forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile  DT * );
+void *                  ?=?(                void *          &,                void * );
+void *                  ?=?(                void * volatile &,                void * );
+const void *            ?=?( const          void *          &,                void * );
+const void *            ?=?( const          void * volatile &,                void * );
+const void *            ?=?( const          void *          &, const          void * );
+const void *            ?=?( const          void * volatile &, const          void * );
+volatile void *         ?=?(       volatile void *          &,                void * );
+volatile void *         ?=?(       volatile void * volatile &,                void * );
+volatile void *         ?=?(       volatile void *          &,       volatile void * );
+volatile void *         ?=?(       volatile void * volatile &,       volatile void * );
+const volatile void *   ?=?( const volatile void *          &,                void * );
+const volatile void *   ?=?( const volatile void * volatile &,                void * );
+const volatile void *   ?=?( const volatile void *          &, const          void * );
+const volatile void *   ?=?( const volatile void * volatile &, const          void * );
+const volatile void *   ?=?( const volatile void *          &,       volatile void * );
+const volatile void *   ?=?( const volatile void * volatile &,       volatile void * );
+const volatile void *   ?=?( const volatile void *          &, const volatile void * );
+const volatile void *   ?=?( const volatile void * volatile &, const volatile void * );
+//forall( dtype DT ) DT *                       ?=?(                DT *          &, zero_t );
+//forall( dtype DT ) DT *                       ?=?(                DT * volatile &, zero_t );
+forall( dtype DT ) const DT *           ?=?( const          DT *          &, zero_t );
+forall( dtype DT ) const DT *           ?=?( const          DT * volatile &, zero_t );
+//forall( dtype DT ) volatile DT *      ?=?( volatile       DT *          &, zero_t );
+//forall( dtype DT ) volatile DT *      ?=?( volatile       DT * volatile &, zero_t );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile DT *          &, zero_t );
+forall( dtype DT ) const volatile DT *  ?=?( const volatile DT * volatile &, zero_t );
+forall( ftype FT ) FT *                 ?=?( FT *          &, zero_t );
+forall( ftype FT ) FT *                 ?=?( FT * volatile &, zero_t );
+forall( dtype T | sized(T) ) T *                        ?+=?(                T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                        ?+=?(                T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T *          ?+=?( const          T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T *          ?+=?( const          T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *               ?+=?(       volatile T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *               ?+=?(       volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?+=?( const volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                        ?-=?(                T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) T *                        ?-=?(                T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T *          ?-=?( const          T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) const T *          ?-=?( const          T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *               ?-=?(       volatile T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) volatile T *               ?-=?(       volatile T * volatile &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T *          &, ptrdiff_t );
+forall( dtype T | sized(T) ) const volatile T * ?-=?( const volatile T * volatile &, ptrdiff_t );
+_Bool                   ?=?( _Bool &, _Bool ),                                  ?=?( volatile _Bool &, _Bool );
+char                    ?=?( char &, char ),                                    ?=?( volatile char &, char );
+char signed             ?=?( char signed &, char signed ),                      ?=?( volatile char signed &, char signed );
+char unsigned           ?=?( char unsigned &, char unsigned ),                  ?=?( volatile char unsigned &, char unsigned );
+int short               ?=?( int short &, int short ),                          ?=?( volatile int short &, int short );
+int short unsigned      ?=?( int short unsigned &, int short unsigned ),        ?=?( volatile int short unsigned &, int short unsigned );
+signed int              ?=?( signed int &, signed int ),                        ?=?( volatile signed int &, signed int );
+unsigned int            ?=?( unsigned &, unsigned ),                            ?=?( volatile unsigned &, unsigned );
+signed long int         ?=?( signed long int &, signed long int ),              ?=?( volatile signed long int &, signed long int );
+unsigned long int       ?=?( unsigned long int &, unsigned long int ),          ?=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?=?( signed long long int &, signed long long int ),    ?=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int );
+zero_t          ?=?( zero_t &, zero_t );
+one_t                   ?=?( one_t &, one_t );
+_Bool                   ?*=?( _Bool &, _Bool ),                                 ?*=?( volatile _Bool &, _Bool );
+char                    ?*=?( char &, char ),                                   ?*=?( volatile char &, char );
+char signed             ?*=?( char signed &, char signed ),                     ?*=?( volatile char signed &, char signed );
+char unsigned           ?*=?( char unsigned &, char unsigned ),                 ?*=?( volatile char unsigned &, char unsigned );
+int short               ?*=?( int short &, int short ),                         ?*=?( volatile int short &, int short );
+int short unsigned      ?*=?( int short unsigned &, int short unsigned ),       ?*=?( volatile int short unsigned &, int short unsigned );
+signed int              ?*=?( signed int &, signed int ),                       ?*=?( volatile signed int &, signed int );
+unsigned int            ?*=?( unsigned &, unsigned ),                           ?*=?( volatile unsigned &, unsigned );
+signed long int         ?*=?( signed long int &, signed long int ),             ?*=?( volatile signed long int &, signed long int );
+unsigned long int       ?*=?( unsigned long int &, unsigned long int ),         ?*=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?*=?( signed long long int &, signed long long int ),   ?*=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?*=?( unsigned long long int &, unsigned long long int ), ?*=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?/=?( _Bool &, _Bool ),                                 ?/=?( volatile _Bool &, _Bool );
+char                    ?/=?( char &, char ),                                   ?/=?( volatile char &, char );
+char signed             ?/=?( char signed &, char signed ),                     ?/=?( volatile char signed &, char signed );
+char unsigned           ?/=?( char unsigned &, char unsigned ),                 ?/=?( volatile char unsigned &, char unsigned );
+int short               ?/=?( int short &, int short ),                         ?/=?( volatile int short &, int short );
+int short unsigned      ?/=?( int short unsigned &, int short unsigned ),       ?/=?( volatile int short unsigned &, int short unsigned );
+signed int              ?/=?( signed int &, signed int ),                       ?/=?( volatile signed int &, signed int );
+unsigned int            ?/=?( unsigned &, unsigned ),                           ?/=?( volatile unsigned &, unsigned );
+signed long int         ?/=?( signed long int &, signed long int ),             ?/=?( volatile signed long int &, signed long int );
+unsigned long int       ?/=?( unsigned long int &, unsigned long int ),         ?/=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?/=?( signed long long int &, signed long long int ),   ?/=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?/=?( unsigned long long int &, unsigned long long int ), ?/=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?%=?( _Bool &, _Bool ),                                 ?%=?( volatile _Bool &, _Bool );
+char                    ?%=?( char &, char ),                                   ?%=?( volatile char &, char );
+char signed             ?%=?( char signed &, char signed ),                     ?%=?( volatile char signed &, char signed );
+char unsigned           ?%=?( char unsigned &, char unsigned ),                 ?%=?( volatile char unsigned &, char unsigned );
+int short               ?%=?( int short &, int short ),                         ?%=?( volatile int short &, int short );
+int short unsigned      ?%=?( int short unsigned &, int short unsigned ),       ?%=?( volatile int short unsigned &, int short unsigned );
+signed int              ?%=?( signed int &, signed int ),                       ?%=?( volatile signed int &, signed int );
+unsigned int            ?%=?( unsigned &, unsigned ),                           ?%=?( volatile unsigned &, unsigned );
+signed long int         ?%=?( signed long int &, signed long int ),             ?%=?( volatile signed long int &, signed long int );
+unsigned long int       ?%=?( unsigned long int &, unsigned long int ),         ?%=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?%=?( signed long long int &, signed long long int ),   ?%=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?%=?( unsigned long long int &, unsigned long long int ), ?%=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?+=?( _Bool &, _Bool ),                                 ?+=?( volatile _Bool &, _Bool );
+char                    ?+=?( char &, char ),                                   ?+=?( volatile char &, char );
+char signed             ?+=?( char signed &, char signed ),                     ?+=?( volatile char signed &, char signed );
+char unsigned           ?+=?( char unsigned &, char unsigned ),                 ?+=?( volatile char unsigned &, char unsigned );
+int short               ?+=?( int short &, int short ),                         ?+=?( volatile int short &, int short );
+int short unsigned      ?+=?( int short unsigned &, int short unsigned ),       ?+=?( volatile int short unsigned &, int short unsigned );
+signed int              ?+=?( signed int &, signed int ),                       ?+=?( volatile signed int &, signed int );
+unsigned int            ?+=?( unsigned &, unsigned ),                           ?+=?( volatile unsigned &, unsigned );
+signed long int         ?+=?( signed long int &, signed long int ),             ?+=?( volatile signed long int &, signed long int );
+unsigned long int       ?+=?( unsigned long int &, unsigned long int ),         ?+=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?+=?( signed long long int &, signed long long int ),   ?+=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?+=?( unsigned long long int &, unsigned long long int ), ?+=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?-=?( _Bool &, _Bool ),                                 ?-=?( volatile _Bool &, _Bool );
+char                    ?-=?( char &, char ),                                   ?-=?( volatile char &, char );
+char signed             ?-=?( char signed &, char signed ),                     ?-=?( volatile char signed &, char signed );
+char unsigned           ?-=?( char unsigned &, char unsigned ),                 ?-=?( volatile char unsigned &, char unsigned );
+int short               ?-=?( int short &, int short ),                         ?-=?( volatile int short &, int short );
+int short unsigned      ?-=?( int short unsigned &, int short unsigned ),       ?-=?( volatile int short unsigned &, int short unsigned );
+signed int              ?-=?( signed int &, signed int ),                       ?-=?( volatile signed int &, signed int );
+unsigned int            ?-=?( unsigned &, unsigned ),                           ?-=?( volatile unsigned &, unsigned );
+signed long int         ?-=?( signed long int &, signed long int ),             ?-=?( volatile signed long int &, signed long int );
+unsigned long int       ?-=?( unsigned long int &, unsigned long int ),         ?-=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?-=?( signed long long int &, signed long long int ),   ?-=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?-=?( unsigned long long int &, unsigned long long int ), ?-=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?<<=?( _Bool &, _Bool ),                                ?<<=?( volatile _Bool &, _Bool );
+char                    ?<<=?( char &, char ),                                  ?<<=?( volatile char &, char );
+char signed             ?<<=?( char signed &, char signed ),                    ?<<=?( volatile char signed &, char signed );
+char unsigned           ?<<=?( char unsigned &, char unsigned ),                ?<<=?( volatile char unsigned &, char unsigned );
+int short               ?<<=?( int short &, int short ),                        ?<<=?( volatile int short &, int short );
+int short unsigned      ?<<=?( int short unsigned &, int short unsigned ),      ?<<=?( volatile int short unsigned &, int short unsigned );
+signed int              ?<<=?( signed int &, signed int ),                      ?<<=?( volatile signed int &, signed int );
+unsigned int            ?<<=?( unsigned &, unsigned ),                          ?<<=?( volatile unsigned &, unsigned );
+signed long int         ?<<=?( signed long int &, signed long int ),            ?<<=?( volatile signed long int &, signed long int );
+unsigned long int       ?<<=?( unsigned long int &, unsigned long int ),        ?<<=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?<<=?( signed long long int &, signed long long int ),  ?<<=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?<<=?( unsigned long long int &, unsigned long long int ), ?<<=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?>>=?( _Bool &, _Bool ),                                ?>>=?( volatile _Bool &, _Bool );
+char                    ?>>=?( char &, char ),                                  ?>>=?( volatile char &, char );
+char signed             ?>>=?( char signed &, char signed ),                    ?>>=?( volatile char signed &, char signed );
+char unsigned           ?>>=?( char unsigned &, char unsigned ),                ?>>=?( volatile char unsigned &, char unsigned );
+int short               ?>>=?( int short &, int short ),                        ?>>=?( volatile int short &, int short );
+int short unsigned      ?>>=?( int short unsigned &, int short unsigned ),      ?>>=?( volatile int short unsigned &, int short unsigned );
+signed int              ?>>=?( signed int &, signed int ),                      ?>>=?( volatile signed int &, signed int );
+unsigned int            ?>>=?( unsigned &, unsigned ),                          ?>>=?( volatile unsigned &, unsigned );
+signed long int         ?>>=?( signed long int &, signed long int ),            ?>>=?( volatile signed long int &, signed long int );
+unsigned long int       ?>>=?( unsigned long int &, unsigned long int ),        ?>>=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?>>=?( signed long long int &, signed long long int ),  ?>>=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?>>=?( unsigned long long int &, unsigned long long int ), ?>>=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?&=?( _Bool &, _Bool ),                                 ?&=?( volatile _Bool &, _Bool );
+char                    ?&=?( char &, char ),                                   ?&=?( volatile char &, char );
+char signed             ?&=?( char signed &, char signed ),                     ?&=?( volatile char signed &, char signed );
+char unsigned           ?&=?( char unsigned &, char unsigned ),                 ?&=?( volatile char unsigned &, char unsigned );
+int short               ?&=?( int short &, int short ),                         ?&=?( volatile int short &, int short );
+int short unsigned      ?&=?( int short unsigned &, int short unsigned ),       ?&=?( volatile int short unsigned &, int short unsigned );
+signed int              ?&=?( signed int &, signed int ),                       ?&=?( volatile signed int &, signed int );
+unsigned int            ?&=?( unsigned &, unsigned ),                           ?&=?( volatile unsigned &, unsigned );
+signed long int         ?&=?( signed long int &, signed long int ),             ?&=?( volatile signed long int &, signed long int );
+unsigned long int       ?&=?( unsigned long int &, unsigned long int ),         ?&=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?&=?( signed long long int &, signed long long int ),   ?&=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?&=?( unsigned long long int &, unsigned long long int ), ?&=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?|=?( _Bool &, _Bool ),                                 ?|=?( volatile _Bool &, _Bool );
+char                    ?|=?( char &, char ),                                   ?|=?( volatile char &, char );
+char signed             ?|=?( char signed &, char signed ),                     ?|=?( volatile char signed &, char signed );
+char unsigned           ?|=?( char unsigned &, char unsigned ),                 ?|=?( volatile char unsigned &, char unsigned );
+int short               ?|=?( int short &, int short ),                         ?|=?( volatile int short &, int short );
+int short unsigned      ?|=?( int short unsigned &, int short unsigned ),       ?|=?( volatile int short unsigned &, int short unsigned );
+signed int              ?|=?( signed int &, signed int ),                       ?|=?( volatile signed int &, signed int );
+unsigned int            ?|=?( unsigned &, unsigned ),                           ?|=?( volatile unsigned &, unsigned );
+signed long int         ?|=?( signed long int &, signed long int ),             ?|=?( volatile signed long int &, signed long int );
+unsigned long int       ?|=?( unsigned long int &, unsigned long int ),         ?|=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?|=?( signed long long int &, signed long long int ),   ?|=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?|=?( unsigned long long int &, unsigned long long int ), ?|=?( volatile unsigned long long int &, unsigned long long int );
+_Bool                   ?^=?( _Bool &, _Bool ),                                 ?^=?( volatile _Bool &, _Bool );
+char                    ?^=?( char &, char ),                                   ?^=?( volatile char &, char );
+char signed             ?^=?( char signed &, char signed ),                     ?^=?( volatile char signed &, char signed );
+char unsigned           ?^=?( char unsigned &, char unsigned ),                 ?^=?( volatile char unsigned &, char unsigned );
+int short               ?^=?( int short &, int short ),                         ?^=?( volatile int short &, int short );
+int short unsigned      ?^=?( int short unsigned &, int short unsigned ),       ?^=?( volatile int short unsigned &, int short unsigned );
+signed int              ?^=?( signed int &, signed int ),                       ?^=?( volatile signed int &, signed int );
+unsigned int            ?^=?( unsigned &, unsigned ),                           ?^=?( volatile unsigned &, unsigned );
+signed long int         ?^=?( signed long int &, signed long int ),             ?^=?( volatile signed long int &, signed long int );
+unsigned long int       ?^=?( unsigned long int &, unsigned long int ),         ?^=?( volatile unsigned long int &, unsigned long int );
+signed long long int    ?^=?( signed long long int &, signed long long int ),   ?^=?( volatile signed long long int &, signed long long int );
+unsigned long long int  ?^=?( unsigned long long int &, unsigned long long int ), ?^=?( volatile unsigned long long int &, unsigned long long int );
+float                   ?=?(  float &, float ), ?=?(  volatile float &, float ),
+                        ?*=?( float &, float ), ?*=?( volatile float &, float ),
+                        ?/=?( float &, float ), ?/=?( volatile float &, float ),
+                        ?+=?( float &, float ), ?+=?( volatile float &, float ),
+                        ?-=?( float &, float ), ?-=?( volatile float &, float );
+double                  ?=?(  double &, double ), ?=?(  volatile double &, double ),
+                        ?*=?( double &, double ), ?*=?( volatile double &, double ),
+                        ?/=?( double &, double ), ?/=?( volatile double &, double ),
+                        ?+=?( double &, double ), ?+=?( volatile double &, double ),
+                        ?-=?( double &, double ), ?-=?( volatile double &, double );
+long double             ?=?(  long double &, long double ), ?=?(  volatile long double &, long double ),
+                        ?*=?( long double &, long double ), ?*=?( volatile long double &, long double ),
+                        ?/=?( long double &, long double ), ?/=?( volatile long double &, long double ),
+                        ?+=?( long double &, long double ), ?+=?( volatile long double &, long double ),
+                        ?-=?( long double &, long double ), ?-=?( volatile long double &, long double );
+float _Complex          ?=?(  float _Complex &, float _Complex ), ?=?(  volatile float _Complex &, float _Complex ),
+                        ?*=?( float _Complex &, float _Complex ), ?*=?( volatile float _Complex &, float _Complex ),
+                        ?/=?( float _Complex &, float _Complex ), ?/=?( volatile float _Complex &, float _Complex ),
+                        ?+=?( float _Complex &, float _Complex ), ?+=?( volatile float _Complex &, float _Complex ),
+                        ?-=?( float _Complex &, float _Complex ), ?-=?( volatile float _Complex &, float _Complex );
+double _Complex         ?=?(  double _Complex &, double _Complex ), ?=?(  volatile double _Complex &, double _Complex ),
+                        ?*=?( double _Complex &, double _Complex ), ?*=?( volatile double _Complex &, double _Complex ),
+                        ?/=?( double _Complex &, double _Complex ), ?/=?( volatile double _Complex &, double _Complex ),
+                        ?+=?( double _Complex &, double _Complex ), ?+=?( volatile double _Complex &, double _Complex ),
+                        ?-=?( double _Complex &, double _Complex ), ?-=?( volatile double _Complex &, double _Complex );
+long double _Complex    ?=?(  long double _Complex &, long double _Complex ), ?=?(  volatile long double _Complex &, long double _Complex ),
+                        ?*=?( long double _Complex &, long double _Complex ), ?*=?( volatile long double _Complex &, long double _Complex ),
+                        ?/=?( long double _Complex &, long double _Complex ), ?/=?( volatile long double _Complex &, long double _Complex ),
+                        ?+=?( long double _Complex &, long double _Complex ), ?+=?( volatile long double _Complex &, long double _Complex ),
+                        ?-=?( long double _Complex &, long double _Complex ), ?-=?( volatile long double _Complex &, long double _Complex );
 …
 // default ctor
 void    ?{}( _Bool * );
 void    ?{}( char * );
 void    ?{}( unsigned char * );
 void    ?{}( char signed * );
 void    ?{}( int short * );
 void    ?{}( int short unsigned * );
 void    ?{}( signed int * );
 void    ?{}( unsigned int * );
 void    ?{}( signed long int * );
 void    ?{}( unsigned long int * );
 void    ?{}( signed long long int * );
 void    ?{}( unsigned long long int * );
 void    ?{}( float * );
 void    ?{}( double * );
 void    ?{}( long double * );
 void    ?{}( float _Complex * );
 void    ?{}( double _Complex * );
 void    ?{}( long double _Complex * );
 void    ?{}( zero_t * );
 void    ?{}( one_t * );
+void    ?{}( _Bool & );
+void    ?{}( char & );
+void    ?{}( unsigned char & );
+void    ?{}( char signed & );
+void    ?{}( int short & );
+void    ?{}( int short unsigned & );
+void    ?{}( signed int & );
+void    ?{}( unsigned int & );
+void    ?{}( signed long int & );
+void    ?{}( unsigned long int & );
+void    ?{}( signed long long int & );
+void    ?{}( unsigned long long int & );
+void    ?{}( float & );
+void    ?{}( double & );
+void    ?{}( long double & );
+void    ?{}( float _Complex & );
+void    ?{}( double _Complex & );
+void    ?{}( long double _Complex & );
+void    ?{}( zero_t & );
+void    ?{}( one_t & );
 // copy ctor
 void    ?{}( _Bool *, _Bool );
 void    ?{}( char *, char );
 void    ?{}( unsigned char *, unsigned char );
 void    ?{}( char signed *, char signed );
 void    ?{}( int short *, int short );
 void    ?{}( int short unsigned *, int short unsigned );
 void    ?{}( signed int *, signed int);
 void    ?{}( unsigned int *, unsigned int);
 void    ?{}( signed long int *, signed long int);
 void    ?{}( unsigned long int *, unsigned long int);
 void    ?{}( signed long long int *, signed long long int);
 void    ?{}( unsigned long long int *, unsigned long long int);
 void    ?{}( float *, float);
 void    ?{}( double *, double);
 void    ?{}( long double *, long double);
 void    ?{}( float _Complex *, float _Complex);
 void    ?{}( double _Complex *, double _Complex);
 void    ?{}( long double _Complex *, long double _Complex);
 void    ?{}( zero_t *, zero_t );
 void    ?{}( one_t *, one_t );
+void    ?{}( _Bool &, _Bool );
+void    ?{}( char &, char );
+void    ?{}( unsigned char &, unsigned char );
+void    ?{}( char signed &, char signed );
+void    ?{}( int short &, int short );
+void    ?{}( int short unsigned &, int short unsigned );
+void    ?{}( signed int &, signed int);
+void    ?{}( unsigned int &, unsigned int);
+void    ?{}( signed long int &, signed long int);
+void    ?{}( unsigned long int &, unsigned long int);
+void    ?{}( signed long long int &, signed long long int);
+void    ?{}( unsigned long long int &, unsigned long long int);
+void    ?{}( float &, float);
+void    ?{}( double &, double);
+void    ?{}( long double &, long double);
+void    ?{}( float _Complex &, float _Complex);
+void    ?{}( double _Complex &, double _Complex);
+void    ?{}( long double _Complex &, long double _Complex);
+void    ?{}( zero_t &, zero_t );
+void    ?{}( one_t &, one_t );
 // dtor
 void    ^?{}( _Bool * );
 void    ^?{}( char * );
 void    ^?{}( char unsigned * );
 void    ^?{}( char signed * );
 void    ^?{}( int short * );
 void    ^?{}( int short unsigned * );
 void    ^?{}( signed int * );
 void    ^?{}( unsigned int * );
 void    ^?{}( signed long int * );
 void    ^?{}( unsigned long int * );
 void    ^?{}( signed long long int * );
 void    ^?{}( unsigned long long int * );
 void    ^?{}( float * );
 void    ^?{}( double * );
 void    ^?{}( long double * );
 void    ^?{}( float _Complex * );
 void    ^?{}( double _Complex * );
 void    ^?{}( long double _Complex * );
 void    ^?{}( zero_t * );
 void    ^?{}( one_t * );
+void    ^?{}( _Bool & );
+void    ^?{}( char & );
+void    ^?{}( char unsigned & );
+void    ^?{}( char signed & );
+void    ^?{}( int short & );
+void    ^?{}( int short unsigned & );
+void    ^?{}( signed int & );
+void    ^?{}( unsigned int & );
+void    ^?{}( signed long int & );
+void    ^?{}( unsigned long int & );
+void    ^?{}( signed long long int & );
+void    ^?{}( unsigned long long int & );
+void    ^?{}( float & );
+void    ^?{}( double & );
+void    ^?{}( long double & );
+void    ^?{}( float _Complex & );
+void    ^?{}( double _Complex & );
+void    ^?{}( long double _Complex & );
+void    ^?{}( zero_t & );
+void    ^?{}( one_t & );
 // // default ctor
 …
 // copied from assignment section
 // copy constructors
 forall( ftype FT ) void ?{}( FT **, FT * );
 forall( ftype FT ) void ?{}( FT * volatile *, FT * );
 forall( dtype DT ) void ?{}(                 DT *          *,                   DT * );
 forall( dtype DT ) void ?{}( const           DT *          *,                   DT * );
 forall( dtype DT ) void ?{}( const           DT *          *, const             DT * );
 forall( dtype DT ) void ?{}(       volatile  DT *          *,                   DT * );
 forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    DT * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *,                   DT * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *, const             DT * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    DT * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    DT * );
 forall( dtype DT ) void ?{}(                 DT *          *,                   void * );
 forall( dtype DT ) void ?{}( const           DT *          *,                   void * );
 forall( dtype DT ) void ?{}( const           DT *          *, const             void * );
 forall( dtype DT ) void ?{}(       volatile  DT *          *,                   void * );
 forall( dtype DT ) void ?{}(       volatile  DT *          *,       volatile    void * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *,                   void * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *, const             void * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *,       volatile    void * );
 forall( dtype DT ) void ?{}( const volatile  DT *          *, const volatile    void * );
 forall( dtype DT ) void ?{}(                 void *          *,                 DT * );
 forall( dtype DT ) void ?{}( const           void *          *,                 DT * );
 forall( dtype DT ) void ?{}( const           void *          *, const           DT * );
 forall( dtype DT ) void ?{}(        volatile void *          *,                 DT * );
 forall( dtype DT ) void ?{}(        volatile void *          *,       volatile  DT * );
 forall( dtype DT ) void ?{}( const volatile void *           *,                 DT * );
 forall( dtype DT ) void ?{}( const volatile void *           *, const           DT * );
 forall( dtype DT ) void ?{}( const volatile void *           *,       volatile  DT * );
 forall( dtype DT ) void ?{}( const volatile void *           *, const volatile  DT * );
 void    ?{}(                void *          *,                void * );
 void    ?{}( const          void *          *,                void * );
 void    ?{}( const          void *          *, const          void * );
 void    ?{}(       volatile void *          *,                void * );
 void    ?{}(       volatile void *          *,       volatile void * );
 void    ?{}( const volatile void *          *,                void * );
 void    ?{}( const volatile void *          *, const          void * );
 void    ?{}( const volatile void *          *,       volatile void * );
 void    ?{}( const volatile void *          *, const volatile void * );
 // //forall( dtype DT ) void ?{}(                   DT *          *, zero_t );
 // //forall( dtype DT ) void ?{}(                   DT * volatile *, zero_t );
 // forall( dtype DT ) void ?{}( const       DT *          *, zero_t );
 // //forall( dtype DT ) void ?{}( volatile          DT *          *, zero_t );
 // //forall( dtype DT ) void ?{}( volatile          DT * volatile *, zero_t );
 // forall( dtype DT ) void ?{}( const volatile DT *       *, zero_t );
 // forall( ftype FT ) void      ?{}( FT *          *, zero_t );
+forall( ftype FT ) void ?{}( FT *&, FT * );
+forall( ftype FT ) void ?{}( FT * volatile &, FT * );
+forall( dtype DT ) void ?{}(                 DT *          &,                   DT * );
+forall( dtype DT ) void ?{}( const           DT *          &,                   DT * );
+forall( dtype DT ) void ?{}( const           DT *          &, const             DT * );
+forall( dtype DT ) void ?{}(       volatile  DT *          &,                   DT * );
+forall( dtype DT ) void ?{}(       volatile  DT *          &,       volatile    DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &,                   DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &, const             DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &,       volatile    DT * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &, const volatile    DT * );
+forall( dtype DT ) void ?{}(                 DT *          &,                   void * );
+forall( dtype DT ) void ?{}( const           DT *          &,                   void * );
+forall( dtype DT ) void ?{}( const           DT *          &, const             void * );
+forall( dtype DT ) void ?{}(       volatile  DT *          &,                   void * );
+forall( dtype DT ) void ?{}(       volatile  DT *          &,       volatile    void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &,                   void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &, const             void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &,       volatile    void * );
+forall( dtype DT ) void ?{}( const volatile  DT *          &, const volatile    void * );
+forall( dtype DT ) void ?{}(                 void *          &,                 DT * );
+forall( dtype DT ) void ?{}( const           void *          &,                 DT * );
+forall( dtype DT ) void ?{}( const           void *          &, const           DT * );
+forall( dtype DT ) void ?{}(        volatile void *          &,                 DT * );
+forall( dtype DT ) void ?{}(        volatile void *          &,       volatile  DT * );
+forall( dtype DT ) void ?{}( const volatile void *           &,                 DT * );
+forall( dtype DT ) void ?{}( const volatile void *           &, const           DT * );
+forall( dtype DT ) void ?{}( const volatile void *           &,       volatile  DT * );
+forall( dtype DT ) void ?{}( const volatile void *           &, const volatile  DT * );
+void    ?{}(                void *          &,                void * );
+void    ?{}( const          void *          &,                void * );
+void    ?{}( const          void *          &, const          void * );
+void    ?{}(       volatile void *          &,                void * );
+void    ?{}(       volatile void *          &,       volatile void * );
+void    ?{}( const volatile void *          &,                void * );
+void    ?{}( const volatile void *          &, const          void * );
+void    ?{}( const volatile void *          &,       volatile void * );
+void    ?{}( const volatile void *          &, const volatile void * );
+//forall( dtype DT ) void ?{}(              DT *          &, zero_t );
+//forall( dtype DT ) void ?{}(              DT * volatile &, zero_t );
+forall( dtype DT ) void ?{}( const          DT *          &, zero_t );
+//forall( dtype DT ) void ?{}( volatile     DT *          &, zero_t );
+//forall( dtype DT ) void ?{}( volatile     DT * volatile &, zero_t );
+forall( dtype DT ) void ?{}( const volatile DT *          &, zero_t );
+forall( ftype FT ) void ?{}( FT *          &, zero_t );
 // default ctors
 forall( ftype FT ) void ?{}( FT *          * );
 forall( dtype DT ) void ?{}(                 DT *          *);
 forall( dtype DT ) void ?{}( const           DT *          *);
 forall( dtype DT ) void ?{}(       volatile  DT *          *);
 forall( dtype DT ) void ?{}( const volatile  DT *          *);
 void    ?{}(                void *          *);
 void    ?{}( const          void *          *);
 void    ?{}(       volatile void *          *);
 void    ?{}( const volatile void *          *);
+forall( ftype FT ) void ?{}( FT *          & );
+forall( dtype DT ) void ?{}(                 DT *          &);
+forall( dtype DT ) void ?{}( const           DT *          &);
+forall( dtype DT ) void ?{}(       volatile  DT *          &);
+forall( dtype DT ) void ?{}( const volatile  DT *          &);
+void    ?{}(                void *          &);
+void    ?{}( const          void *          &);
+void    ?{}(       volatile void *          &);
+void    ?{}( const volatile void *          &);
 // dtors
 forall( ftype FT ) void ^?{}( FT *         * );
 forall( dtype DT ) void ^?{}(                DT *          *);
 forall( dtype DT ) void ^?{}( const          DT *          *);
 forall( dtype DT ) void ^?{}(      volatile  DT *          *);
 forall( dtype DT ) void ^?{}( const volatile  DT *         *);
 void    ^?{}(               void *          *);
 void    ^?{}( const         void *          *);
 void    ^?{}(      volatile void *          *);
 void    ^?{}( const volatile void *         *);
+forall( ftype FT ) void ^?{}( FT *         & );
+forall( dtype DT ) void ^?{}(                DT *          &);
+forall( dtype DT ) void ^?{}( const          DT *          &);
+forall( dtype DT ) void ^?{}(      volatile  DT *          &);
+forall( dtype DT ) void ^?{}( const volatile  DT *         &);
+void    ^?{}(               void *          &);
+void    ^?{}( const         void *          &);
+void    ^?{}(      volatile void *          &);
+void    ^?{}( const volatile void *         &);
 // Local Variables: //

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

-              raf08051
+              r28e58fd
+}
 struct S {
 int __i__i_1;
+    int __i__i_1;
 };
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__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_R2sS_autogen___1(struct S *___dst__R2sS_1){
+    ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))=___src__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 ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_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_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
+    ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
+    ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
 …
     int __b__i_2;
     int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
     ((void)(__x__PFPi_ii__2=((_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5)) , _tmp_cp_ret0)));
     ((void)((*((int *(**)(int __x__i_1, int __y__i_1))(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0)));
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
         __attribute__ ((unused)) const int ___retval_f1__Ci_2;

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

-              raf08051
+              r28e58fd
 __attribute__ ((unused)) struct __anonymous0 {
 };
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+}
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__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_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){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 …
 __attribute__ ((unused)) struct Agn2 {
 };
 static inline void ___constructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1);
 static inline void ___constructor__F_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___destructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1);
 static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___constructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1){
+}
 static inline void ___constructor__F_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
 static inline void ___destructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1){
+}
 static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_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_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){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_P5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
+    ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
     return ((struct Agn2 )___ret__5sAgn2_1);
+}
 …
     __attribute__ ((unused,unused)) int *__f9__Pi_1;
 };
 static inline void ___constructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1);
 static inline void ___constructor__F_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1);
 static inline void ___destructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1);
 static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1);
 static inline void ___constructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
 static inline void ___destructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1){
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))) /* ^?{} */);
+}
 static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_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_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).__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).__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).__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){
     struct Fdl ___ret__4sFdl_1;
     ((void)((*___dst__P4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     ((void)((*___dst__P4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     ((void)((*___dst__P4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     ((void)((*___dst__P4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     ((void)((*___dst__P4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     ((void)((*___dst__P4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     ((void)((*___dst__P4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     ((void)((*___dst__P4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     ((void)((*___dst__P4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_P4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___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).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
     return ((struct Fdl )___ret__4sFdl_1);
+}
 static inline void ___constructor__F_P4sFdli_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdlii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=__f8__i_1) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=__f8__i_1) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))=__f9__Pi_1) /* ?{} */);
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, 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).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
 …
         int __i__i_2;
     };
     inline void ___constructor__F_P13s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))) /* ?{} */);
+    }
     inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_P13s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))) /* ^?{} */);
+    }
     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_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){
         struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__P13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
+        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
+        ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+    }
     inline void ___constructor__F_P13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
+        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     ((void)sizeof(struct __anonymous4 ));
 …
         __R__C13e__anonymous5_2,
     };
     inline void ___constructor__F_P13e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2){
+    }
     inline void ___constructor__F_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         ((void)((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2));
+    }
     inline void ___destructor__F_P13e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2){
+    }
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__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){
         enum __anonymous5 ___ret__13e__anonymous5_2;
         ((void)(___ret__13e__anonymous5_2=((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
         return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+    }
 …
     __attribute__ ((unused,unused)) int (*__anonymous_object31)();
 };
 static inline void ___constructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1);
 static inline void ___constructor__F_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1);
 static inline void ___destructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1);
 static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1);
 static inline void ___constructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1){
+}
 static inline void ___constructor__F_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){
+}
 static inline void ___destructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1){
+}
 static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){
+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_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){
     struct Vad ___ret__4sVad_1;
     ((void)___constructor__F_P4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
     return ((struct Vad )___ret__4sVad_1);
+}

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

-              raf08051
+              r28e58fd
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__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_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){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1);
 static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
 static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1);
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
 static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_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__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){
     struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
+    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+}
 static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1);
 static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
 static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1);
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
 static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_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__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){
     struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
+    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+}
 static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1);
 static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
 static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1);
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
 static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_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__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){
     struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
+    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+}
 static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1);
 static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
 static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1);
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
 static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_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__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){
     struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
+    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+}
 static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1);
 static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
 static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1);
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
 static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_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__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){
     struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
+    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+}
 static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1);
 static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
 static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1);
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
 static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_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__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){
     struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
+    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+}
 static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1);
 static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
 static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1);
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
 static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_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__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){
     struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
+    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+}
 static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1);
 static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
 static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1);
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
 static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_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__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){
     struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_P13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
+    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
+    ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+}
 static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
+    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1);
 static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
 static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1);
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
 static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_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__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){
     struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_P13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
+    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
+    ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+}
 static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
+    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1);
 static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
 static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1);
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
 static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_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__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){
     struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
+    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+}
 static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1);
 static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
 static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1);
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
 static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_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__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){
     struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
+    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+}
 static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1);
 static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
 static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1);
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
 static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_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__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){
     struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
+    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+}
 static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1);
 static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
 static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1);
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
 static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_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__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){
     struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
+    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+}
 static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1);
 static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
 static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1);
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
 static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_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__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){
     struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
+    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+}
 static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1);
 static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
 static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1);
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
 static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_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__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){
     struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
+    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+}
 static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1);
 static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
 static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1);
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
 static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_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__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){
     struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
+    ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+}
 static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1);
 static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
 static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1);
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
 static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_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__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){
     struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
+    ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+}
 static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1);
 static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
 static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1);
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
 static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_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__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){
     struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
+    ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+}
 static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1);
 static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
 static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1);
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
 static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_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__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){
     struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
+    ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+}
 static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1);
 static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
 static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1);
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
 static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_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__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){
     struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
+    ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+}
 static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1);
 static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
 static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1);
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
 static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_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__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){
     struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
+    ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+}
 static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1);
 static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
 static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1);
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
 static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_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__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){
     struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
+    ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+}
 static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1);
 static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
 static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1);
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
 static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_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__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){
     struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
+    ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+}
 static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, 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();
 …
     __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((int )___retval_main__i_1);
+}

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

-              raf08051
+              r28e58fd
     __extension__ int __c__i_1;
 };
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__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_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_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=___src__2sS_1.__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=___src__2sS_1.__b__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))=___src__2sS_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_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__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_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
     ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___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));
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, 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_P2sSii_autogen___1(struct S *___dst__P2sS_1, int __a__i_1, int __b__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=__b__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */);
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, 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_P2sSiii_autogen___1(struct S *___dst__P2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=__b__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))=__c__i_1) /* ?{} */);
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1, 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) /* ?{} */);
+}
 __extension__ union U {
 …
     __extension__ int __c__i_1;
 };
 static inline void ___constructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
+static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 static inline void ___constructor__F_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+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_P2uU_autogen___1(union U *___dst__P2uU_1){
+static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
+static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1){
     union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_P2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
     return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
+static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
+}
 __extension__ enum E {
 …
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     int _tmp_cp_ret0;
     ((void)((_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret0));
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     __extension__ int __mary__Fi_i__2(int __p__i_2){
         __attribute__ ((unused)) int ___retval_mary__i_2;
 …
     ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2));
+    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
+}

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

-              raf08051
+              r28e58fd
         __extension__ int __c__i_2;
     };
     inline void ___constructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__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_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=___src__2sS_2.__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=___src__2sS_2.__b__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=___src__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 ___destructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ^?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ^?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__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 struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
+    inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
         struct S ___ret__2sS_2;
         ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
         ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_P2sS2sS_autogen___2((&___ret__2sS_2), ___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)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
         return ((struct S )___ret__2sS_2);
+    }
     inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */);
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, 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_P2sSii_autogen___2(struct S *___dst__P2sS_2, int __a__i_2, int __b__i_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=__b__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */);
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, 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_P2sSiii_autogen___2(struct S *___dst__P2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=__b__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=__c__i_2) /* ?{} */);
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, 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) /* ?{} */);
+    }
     int __i__i_2 = ((int )__extension__ 3);
 …
     __extension__ int __b__i_2;
     __extension__ int __c__i_2;
     ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2));
+    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
 …
         int __i__i_2;
     };
     inline void ___constructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__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_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=___src__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 ___destructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ^?{} */);
+    inline void ___destructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
+        ((void)((*___dst__R3ss2_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
+    inline struct s2 ___operator_assign__F3ss2_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){
         struct s2 ___ret__3ss2_2;
         ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_P3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
+        ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
         return ((struct s2 )___ret__3ss2_2);
+    }
     inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
+        ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 {
         int __i__i_2;
     };
     inline void ___constructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__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_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=___src__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 ___destructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ^?{} */);
+    inline void ___destructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
+        ((void)((*___dst__R3ss3_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
+    inline struct s3 ___operator_assign__F3ss3_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){
         struct s3 ___ret__3ss3_2;
         ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_P3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
+        ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
         return ((struct s3 )___ret__3ss3_2);
+    }
     inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
+        ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 __x1__3ss3_2;
 …
         int __i__i_2;
     };
     inline void ___constructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__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_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=___src__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 ___destructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ^?{} */);
+    inline void ___destructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
+        ((void)((*___dst__R3ss4_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
+    inline struct s4 ___operator_assign__F3ss4_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){
         struct s4 ___ret__3ss4_2;
         ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_P3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
+        ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
         return ((struct s4 )___ret__3ss4_2);
+    }
     inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
+        ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s4 __x2__3ss4_2;
 …
     __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((int )___retval_main__i_1);
+}

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

-              raf08051
+              r28e58fd
     int __i__i_1;
 };
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__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_R2sS_autogen___1(struct S *___dst__R2sS_1){
+    ((void)((*___dst__R2sS_1).__i__i_1) /* ?{} */);
+}
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))=___src__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 ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_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_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
     ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
+    ((void)((*___dst__R2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, int __i__i_1){
+    ((void)((*___dst__R2sS_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 int __f3__Fi_2sS2sSPi__1(struct S __a__2sS_1, struct S __b__2sS_1, int *__c__Pi_1){
 …
     int __b__i_2;
     int *(*_tmp_cp_ret0)(int __x__i_1, int __y__i_1);
     ((void)(__x__PFPi_ii__2=((_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5)) , _tmp_cp_ret0)));
     ((void)((*((int *(**)(int __x__i_1, int __y__i_1))(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(__x__PFPi_ii__2=(((void)(_tmp_cp_ret0=__f10__FPFPi_ii__iPiPid__1(3, (&__a__i_2), (&__b__i_2), 3.5))) , _tmp_cp_ret0)));
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     const int __f1__FCi_iPiPi__2(int __a__i_2, int *__b__Pi_2, int *__c__Pi_2){
         __attribute__ ((unused)) const int ___retval_f1__Ci_2;

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

-              raf08051
+              r28e58fd
 __attribute__ ((unused)) struct __anonymous0 {
 };
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+}
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+}
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__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_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){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 …
 __attribute__ ((unused)) struct Agn2 {
 };
 static inline void ___constructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1);
 static inline void ___constructor__F_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___destructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1);
 static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1);
 static inline void ___constructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1){
+}
 static inline void ___constructor__F_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+}
 static inline void ___destructor__F_P5sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1){
+}
 static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_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_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){
     struct Agn2 ___ret__5sAgn2_1;
     ((void)___constructor__F_P5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
+    ((void)___constructor__F_R5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
     return ((struct Agn2 )___ret__5sAgn2_1);
+}
 …
     __attribute__ ((unused,unused)) int *__f9__Pi_1;
 };
 static inline void ___constructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1);
 static inline void ___constructor__F_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1);
 static inline void ___destructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1);
 static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1);
 static inline void ___constructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=___src__4sFdl_1.__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=___src__4sFdl_1.__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=___src__4sFdl_1.__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=___src__4sFdl_1.__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=___src__4sFdl_1.__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=___src__4sFdl_1.__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=___src__4sFdl_1.__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=___src__4sFdl_1.__f8__i_1) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))=___src__4sFdl_1.__f9__Pi_1) /* ?{} */);
+}
 static inline void ___destructor__F_P4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1){
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))) /* ^?{} */);
+}
 static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_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_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).__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).__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).__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){
     struct Fdl ___ret__4sFdl_1;
     ((void)((*___dst__P4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     ((void)((*___dst__P4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
     ((void)((*___dst__P4sFdl_1).__f3__i_1=___src__4sFdl_1.__f3__i_1));
     ((void)((*___dst__P4sFdl_1).__f4__i_1=___src__4sFdl_1.__f4__i_1));
     ((void)((*___dst__P4sFdl_1).__f5__i_1=___src__4sFdl_1.__f5__i_1));
     ((void)((*___dst__P4sFdl_1).__f6__i_1=___src__4sFdl_1.__f6__i_1));
     ((void)((*___dst__P4sFdl_1).__f7__i_1=___src__4sFdl_1.__f7__i_1));
     ((void)((*___dst__P4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     ((void)((*___dst__P4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
     ((void)___constructor__F_P4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___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).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    ((void)___constructor__F_R4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
     return ((struct Fdl )___ret__4sFdl_1);
+}
 static inline void ___constructor__F_P4sFdli_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdlii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiiiii_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=__f8__i_1) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, int *__f9__Pi_1){
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f1__i_1)))=__f1__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f2__i_1)))=__f2__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f3__i_1)))=__f3__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f4__i_1)))=__f4__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f5__i_1)))=__f5__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f6__i_1)))=__f6__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f7__i_1)))=__f7__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P4sFdl_1).__f8__i_1)))=__f8__i_1) /* ?{} */);
     ((void)((*((int **)(&(*___dst__P4sFdl_1).__f9__Pi_1)))=__f9__Pi_1) /* ?{} */);
+static inline void ___constructor__F_R4sFdli_autogen___1(struct Fdl *___dst__R4sFdl_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdlii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiii_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, 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).__f9__Pi_1) /* ?{} */);
+}
+static inline void ___constructor__F_R4sFdliiiiiiiiPi_autogen___1(struct Fdl *___dst__R4sFdl_1, int __f1__i_1, int __f2__i_1, int __f3__i_1, int __f4__i_1, int __f5__i_1, int __f6__i_1, int __f7__i_1, int __f8__i_1, 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).__f9__Pi_1=__f9__Pi_1) /* ?{} */);
+}
 __attribute__ ((unused)) int __f__Fi___1() asm ( "xyz" );
 …
         int __i__i_2;
     };
     inline void ___constructor__F_P13s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))) /* ?{} */);
+    }
     inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))=___src__13s__anonymous4_2.__i__i_2) /* ?{} */);
+    }
     inline void ___destructor__F_P13s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))) /* ^?{} */);
+    }
     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_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){
         struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__P13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
         ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
+        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
+        ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
         return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+    }
     inline void ___constructor__F_P13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P13s__anonymous4_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__R13s__anonymous4_2, int __i__i_2){
+        ((void)((*___dst__R13s__anonymous4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     ((void)sizeof(struct __anonymous4 ));
 …
         __R__C13e__anonymous5_2,
     };
     inline void ___constructor__F_P13e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2){
+    }
     inline void ___constructor__F_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
         ((void)((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2));
+    }
     inline void ___destructor__F_P13e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2){
+    }
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__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){
         enum __anonymous5 ___ret__13e__anonymous5_2;
         ((void)(___ret__13e__anonymous5_2=((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        ((void)(___ret__13e__anonymous5_2=((*___dst__R13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
         return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+    }
 …
     __attribute__ ((unused,unused)) int (*__anonymous_object31)();
 };
 static inline void ___constructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1);
 static inline void ___constructor__F_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1);
 static inline void ___destructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1);
 static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1);
 static inline void ___constructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1){
+}
 static inline void ___constructor__F_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){
+}
 static inline void ___destructor__F_P4sVad_autogen___1(struct Vad *___dst__P4sVad_1){
+}
 static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){
+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_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){
     struct Vad ___ret__4sVad_1;
     ((void)___constructor__F_P4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    ((void)___constructor__F_R4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
     return ((struct Vad )___ret__4sVad_1);
+}

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

-              raf08051
+              r28e58fd
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1);
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1);
 static inline void ___constructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=___src__13s__anonymous0_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__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_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){
     struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
     return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous0_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__R13s__anonymous0_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous0_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous0 __x10__CV13s__anonymous0_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1);
 static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
 static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1);
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1);
 static inline void ___constructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=___src__13s__anonymous1_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_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__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){
     struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
+    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
     return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+}
 static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous1_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__R13s__anonymous1_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous1_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous1 __x11__CV13s__anonymous1_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1);
 static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
 static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1);
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1);
 static inline void ___constructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=___src__13s__anonymous2_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_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__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){
     struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
+    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
     return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+}
 static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous2_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__R13s__anonymous2_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous2_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 volatile const struct __anonymous2 __x12__CV13s__anonymous2_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1);
 static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
 static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1);
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1);
 static inline void ___constructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=___src__13s__anonymous3_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_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__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){
     struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
+    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
     return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+}
 static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous3_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__R13s__anonymous3_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous3_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous3 __x13__CV13s__anonymous3_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1);
 static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
 static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1);
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1);
 static inline void ___constructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=___src__13s__anonymous4_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_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__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){
     struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
+    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
     return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+}
 static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous4_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__R13s__anonymous4_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous4_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous4 __x14__CV13s__anonymous4_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1);
 static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
 static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1);
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1);
 static inline void ___constructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=___src__13s__anonymous5_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_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__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){
     struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
+    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
     return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+}
 static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous5_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__R13s__anonymous5_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous5_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous5 __x15__CV13s__anonymous5_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1);
 static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
 static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1);
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1);
 static inline void ___constructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=___src__13s__anonymous6_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_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__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){
     struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
+    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
     return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+}
 static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous6_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__R13s__anonymous6_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous6_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous6 __x16__CV13s__anonymous6_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1);
 static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
 static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1);
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1);
 static inline void ___constructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=___src__13s__anonymous7_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_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__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){
     struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
     ((void)___constructor__F_P13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
+    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
+    ((void)___constructor__F_R13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
     return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+}
 static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P13s__anonymous7_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__R13s__anonymous7_1, int __i__i_1){
+    ((void)((*___dst__R13s__anonymous7_1).__i__i_1=__i__i_1) /* ?{} */);
+}
 static volatile const struct __anonymous7 __x17__CV13s__anonymous7_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1);
 static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
 static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1);
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1);
 static inline void ___constructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=___src__13s__anonymous8_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_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__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){
     struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
     ((void)___constructor__F_P13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
+    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
+    ((void)___constructor__F_R13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
     return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+}
 static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous8_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__R13s__anonymous8_1, short __i__s_1){
+    ((void)((*___dst__R13s__anonymous8_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous8 __x29__CV13s__anonymous8_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1);
 static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
 static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1);
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1);
 static inline void ___constructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=___src__13s__anonymous9_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P13s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_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__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){
     struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
     ((void)___constructor__F_P13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
+    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
+    ((void)___constructor__F_R13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
     return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+}
 static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P13s__anonymous9_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__R13s__anonymous9_1, short __i__s_1){
+    ((void)((*___dst__R13s__anonymous9_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous9 __x30__CV13s__anonymous9_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1);
 static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
 static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1);
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1);
 static inline void ___constructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=___src__14s__anonymous10_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_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__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){
     struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
+    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
     return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+}
 static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous10_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__R14s__anonymous10_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous10_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 volatile const struct __anonymous10 __x31__CV14s__anonymous10_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1);
 static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
 static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1);
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1);
 static inline void ___constructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=___src__14s__anonymous11_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_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__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){
     struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
+    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
     return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+}
 static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous11_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__R14s__anonymous11_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous11_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous11 __x32__CV14s__anonymous11_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1);
 static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
 static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1);
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1);
 static inline void ___constructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=___src__14s__anonymous12_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_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__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){
     struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
+    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
     return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+}
 static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous12_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__R14s__anonymous12_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous12_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous12 __x33__CV14s__anonymous12_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1);
 static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
 static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1);
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1);
 static inline void ___constructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=___src__14s__anonymous13_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_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__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){
     struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
+    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
     return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+}
 static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous13_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__R14s__anonymous13_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous13_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous13 __x34__CV14s__anonymous13_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1);
 static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
 static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1);
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1);
 static inline void ___constructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=___src__14s__anonymous14_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_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__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){
     struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
+    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
     return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+}
 static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous14_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__R14s__anonymous14_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous14_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous14 __x35__CV14s__anonymous14_1;
 …
     short __i__s_1;
 };
 static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1);
 static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
 static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1);
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1);
 static inline void ___constructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=___src__14s__anonymous15_1.__i__s_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))) /* ^?{} */);
+}
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_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__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){
     struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
     ((void)___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
+    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
+    ((void)___constructor__F_R14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
     return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+}
 static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){
     ((void)((*((short *)(&(*___dst__P14s__anonymous15_1).__i__s_1)))=__i__s_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__R14s__anonymous15_1, short __i__s_1){
+    ((void)((*___dst__R14s__anonymous15_1).__i__s_1=__i__s_1) /* ?{} */);
+}
 static volatile const struct __anonymous15 __x36__CV14s__anonymous15_1;
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1);
 static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
 static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1);
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1);
 static inline void ___constructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=___src__14s__anonymous16_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_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__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){
     struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
+    ((void)((*___dst__R14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
     return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+}
 static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous16_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__R14s__anonymous16_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1);
 static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
 static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1);
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1);
 static inline void ___constructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=___src__14s__anonymous17_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_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__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){
     struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
+    ((void)((*___dst__R14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
     return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+}
 static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous17_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__R14s__anonymous17_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1);
 static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
 static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1);
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1);
 static inline void ___constructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=___src__14s__anonymous18_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_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__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){
     struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
+    ((void)((*___dst__R14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
     return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+}
 static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous18_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__R14s__anonymous18_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1);
 static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
 static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1);
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1);
 static inline void ___constructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=___src__14s__anonymous19_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_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__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){
     struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
+    ((void)((*___dst__R14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
     return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+}
 static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous19_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__R14s__anonymous19_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1);
 static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
 static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1);
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1);
 static inline void ___constructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=___src__14s__anonymous20_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_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__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){
     struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
+    ((void)((*___dst__R14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
     return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+}
 static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous20_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__R14s__anonymous20_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1);
 static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
 static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1);
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1);
 static inline void ___constructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=___src__14s__anonymous21_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_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__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){
     struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
+    ((void)((*___dst__R14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
     return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+}
 static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous21_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__R14s__anonymous21_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1);
 static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
 static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1);
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1);
 static inline void ___constructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=___src__14s__anonymous22_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_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__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){
     struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
+    ((void)((*___dst__R14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
     return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+}
 static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous22_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__R14s__anonymous22_1, 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();
 …
     int __i__i_1;
 };
 static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1);
 static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
 static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1);
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1);
 static inline void ___constructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ?{} */);
+}
 static inline void ___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=___src__14s__anonymous23_1.__i__i_1) /* ?{} */);
+}
 static inline void ___destructor__F_P14s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))) /* ^?{} */);
+}
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_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__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){
     struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
     ((void)___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
+    ((void)((*___dst__R14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
+    ((void)___constructor__F_R14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
     return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+}
 static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){
     ((void)((*((int *)(&(*___dst__P14s__anonymous23_1).__i__i_1)))=__i__i_1) /* ?{} */);
+static inline void ___constructor__F_R14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__R14s__anonymous23_1, 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();
 …
     __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((int )___retval_main__i_1);
+}

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

-              raf08051
+              r28e58fd
     __extension__ int __c__i_1;
 };
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline void ___constructor__F_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___destructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1);
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1);
 static inline void ___constructor__F_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__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_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_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=___src__2sS_1.__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=___src__2sS_1.__b__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))=___src__2sS_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_P2sS_autogen___1(struct S *___dst__P2sS_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ^?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__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_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+static inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___1(struct S *___dst__R2sS_1, struct S ___src__2sS_1){
     struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
     ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
     ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___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));
+    ((void)___constructor__F_R2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
     return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */);
+static inline void ___constructor__F_R2sSi_autogen___1(struct S *___dst__R2sS_1, 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_P2sSii_autogen___1(struct S *___dst__P2sS_1, int __a__i_1, int __b__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=__b__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))) /* ?{} */);
+static inline void ___constructor__F_R2sSii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, 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_P2sSiii_autogen___1(struct S *___dst__P2sS_1, int __a__i_1, int __b__i_1, int __c__i_1){
     ((void)((*((int *)(&(*___dst__P2sS_1).__a__i_1)))=__a__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__b__i_1)))=__b__i_1) /* ?{} */);
     ((void)((*((int *)(&(*___dst__P2sS_1).__c__i_1)))=__c__i_1) /* ?{} */);
+static inline void ___constructor__F_R2sSiii_autogen___1(struct S *___dst__R2sS_1, int __a__i_1, int __b__i_1, 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) /* ?{} */);
+}
 __extension__ union U {
 …
     __extension__ int __c__i_1;
 };
 static inline void ___constructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
+static inline void ___constructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 static inline void ___constructor__F_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+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_P2uU_autogen___1(union U *___dst__P2uU_1){
+static inline void ___destructor__F_R2uU_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1){
+}
 static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
+static inline union U ___operator_assign__F2uU_R2uU2uU_autogen___1(union U *___dst__R2uU_1, union U ___src__2uU_1){
     union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
     ((void)___constructor__F_P2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    ((void)___constructor__F_R2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
     return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
+static inline void ___constructor__F_R2uUi_autogen___1(__attribute__ ((unused)) union U *___dst__R2uU_1, int __src__i_1){
+    ((void)__builtin_memcpy(((void *)___dst__R2uU_1), ((const void *)(&__src__i_1)), sizeof(int )));
+}
 __extension__ enum E {
 …
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     int _tmp_cp_ret0;
     ((void)((_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret0));
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(((void)(_tmp_cp_ret0=__extension__ __fred__Fi_i__1(3))) , _tmp_cp_ret0));
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     __extension__ int __mary__Fi_i__2(int __p__i_2){
         __attribute__ ((unused)) int ___retval_mary__i_2;
 …
     ((void)(((int )((__extension__ __a__i_2>__extension__ __b__i_2)!=((int )0))) ? __extension__ __c__i_2 : __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2));
+    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
+}

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

-              raf08051
+              r28e58fd
         __extension__ int __c__i_2;
     };
     inline void ___constructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__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_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=___src__2sS_2.__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=___src__2sS_2.__b__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=___src__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 ___destructor__F_P2sS_autogen___2(struct S *___dst__P2sS_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ^?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ^?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__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 struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
+    inline struct S ___operator_assign__F2sS_R2sS2sS_autogen___2(struct S *___dst__R2sS_2, struct S ___src__2sS_2){
         struct S ___ret__2sS_2;
         ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
         ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
         ((void)___constructor__F_P2sS2sS_autogen___2((&___ret__2sS_2), ___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)___constructor__F_R2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
         return ((struct S )___ret__2sS_2);
+    }
     inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */);
+    inline void ___constructor__F_R2sSi_autogen___2(struct S *___dst__R2sS_2, 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_P2sSii_autogen___2(struct S *___dst__P2sS_2, int __a__i_2, int __b__i_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=__b__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))) /* ?{} */);
+    inline void ___constructor__F_R2sSii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, 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_P2sSiii_autogen___2(struct S *___dst__P2sS_2, int __a__i_2, int __b__i_2, int __c__i_2){
         ((void)((*((int *)(&(*___dst__P2sS_2).__a__i_2)))=__a__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__b__i_2)))=__b__i_2) /* ?{} */);
         ((void)((*((int *)(&(*___dst__P2sS_2).__c__i_2)))=__c__i_2) /* ?{} */);
+    inline void ___constructor__F_R2sSiii_autogen___2(struct S *___dst__R2sS_2, int __a__i_2, int __b__i_2, 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) /* ?{} */);
+    }
     int __i__i_2 = ((int )__extension__ 3);
 …
     __extension__ int __b__i_2;
     __extension__ int __c__i_2;
     ((void)((__extension__ __a__i_2 , __extension__ __b__i_2) , __extension__ __c__i_2));
+    ((void)(((void)(((void)__extension__ __a__i_2) , __extension__ __b__i_2)) , __extension__ __c__i_2));
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
     ((void)(__extension__ __a__i_2=__extension__ (__extension__ __b__i_2+__extension__ __c__i_2)));
 …
         int __i__i_2;
     };
     inline void ___constructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__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_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=___src__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 ___destructor__F_P3ss2_autogen___2(struct s2 *___dst__P3ss2_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))) /* ^?{} */);
+    inline void ___destructor__F_R3ss2_autogen___2(struct s2 *___dst__R3ss2_2){
+        ((void)((*___dst__R3ss2_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
+    inline struct s2 ___operator_assign__F3ss2_R3ss23ss2_autogen___2(struct s2 *___dst__R3ss2_2, struct s2 ___src__3ss2_2){
         struct s2 ___ret__3ss2_2;
         ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
         ((void)___constructor__F_P3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
+        ((void)((*___dst__R3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        ((void)___constructor__F_R3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
         return ((struct s2 )___ret__3ss2_2);
+    }
     inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss2_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R3ss2i_autogen___2(struct s2 *___dst__R3ss2_2, int __i__i_2){
+        ((void)((*___dst__R3ss2_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 {
         int __i__i_2;
     };
     inline void ___constructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__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_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=___src__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 ___destructor__F_P3ss3_autogen___2(struct s3 *___dst__P3ss3_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))) /* ^?{} */);
+    inline void ___destructor__F_R3ss3_autogen___2(struct s3 *___dst__R3ss3_2){
+        ((void)((*___dst__R3ss3_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
+    inline struct s3 ___operator_assign__F3ss3_R3ss33ss3_autogen___2(struct s3 *___dst__R3ss3_2, struct s3 ___src__3ss3_2){
         struct s3 ___ret__3ss3_2;
         ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
         ((void)___constructor__F_P3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
+        ((void)((*___dst__R3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        ((void)___constructor__F_R3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
         return ((struct s3 )___ret__3ss3_2);
+    }
     inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss3_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R3ss3i_autogen___2(struct s3 *___dst__R3ss3_2, int __i__i_2){
+        ((void)((*___dst__R3ss3_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s3 __x1__3ss3_2;
 …
         int __i__i_2;
     };
     inline void ___constructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__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_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=___src__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 ___destructor__F_P3ss4_autogen___2(struct s4 *___dst__P3ss4_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))) /* ^?{} */);
+    inline void ___destructor__F_R3ss4_autogen___2(struct s4 *___dst__R3ss4_2){
+        ((void)((*___dst__R3ss4_2).__i__i_2) /* ^?{} */);
+    }
     inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
+    inline struct s4 ___operator_assign__F3ss4_R3ss43ss4_autogen___2(struct s4 *___dst__R3ss4_2, struct s4 ___src__3ss4_2){
         struct s4 ___ret__3ss4_2;
         ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
         ((void)___constructor__F_P3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
+        ((void)((*___dst__R3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        ((void)___constructor__F_R3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
         return ((struct s4 )___ret__3ss4_2);
+    }
     inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){
         ((void)((*((int *)(&(*___dst__P3ss4_2).__i__i_2)))=__i__i_2) /* ?{} */);
+    inline void ___constructor__F_R3ss4i_autogen___2(struct s4 *___dst__R3ss4_2, int __i__i_2){
+        ((void)((*___dst__R3ss4_2).__i__i_2=__i__i_2) /* ?{} */);
+    }
     struct s4 __x2__3ss4_2;
 …
     __attribute__ ((unused)) int ___retval_main__i_1;
     int _tmp_cp_ret0;
     ((void)(___retval_main__i_1=((_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1)) , _tmp_cp_ret0)) /* ?{} */);
     ((void)((*((int *)(&_tmp_cp_ret0)))) /* ^?{} */);
+    ((void)(___retval_main__i_1=(((void)(_tmp_cp_ret0=invoke_main(__argc__i_1, __argv__PPc_1, __envp__PPc_1))) , _tmp_cp_ret0)) /* ?{} */);
+    ((void)(_tmp_cp_ret0) /* ^?{} */);
     return ((int )___retval_main__i_1);
+}

src/tests/.expect/castError.txt

-              raf08051
+              r28e58fd
 to:
   char
 Alternatives are:        Cost ( 1, 0, 0 ): Cast of:
+Alternatives are:        Cost ( 1, 0, 0, 0 ): Cast of:
           Variable Expression: f: function
                 accepting unspecified arguments
 …
         Environment:
         Cost ( 1, 0, 0 ): Cast of:
+        Cost ( 1, 0, 0, 0 ): Cast of:
           Variable Expression: f: signed int
 …
         Environment:
         Cost ( 1, 0, 0 ): Cast of:
+        Cost ( 1, 0, 0, 0 ): Cast of:
           Variable Expression: f: double

src/tests/.expect/memberCtors-ERR1.txt

raf08051	r28e58fd
1		memberCtors.c:71 error: in void ?{}(B *b), field a2 used before being constructed
	1	memberCtors.c:71 error: in void ?{}(B &b), field a2 used before being constructed

src/tests/.expect/memberCtors.txt

-              raf08051
+              r28e58fd
 constructing int
 begin construct B
 assign b->a2
 constructing int
 constructing int
 begin construct A
 construct a->x
+assign b.a2
+constructing int
+constructing int
+begin construct A
+construct a.x
 constructing int: 1001
 assign a->y
 assigning int: 0 0
 end construct A
 copy constructing int: 0
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 1001
 assign this->y
+assign a.y
+assigning int: 0 0
+end construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this.x
+copy constructing int: 1001
+assign this.y
 copy constructing int: 0
 destructing int: 0
 …
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 1001
 assign this->y
 copy constructing int: 0
 destructing int: 0
 destructing int: 0
 end copy construct A
 destructing int: 0
 destructing int: 0
 destructing int: 1001
 destructing int: 0
 destructing int: 0
 destructing int: 1001
 construct b->a1
 constructing int
 constructing int
 begin construct A
 construct a->x
+copy construct this.x
+copy constructing int: 1001
+assign this.y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+destructing int: 0
+destructing int: 0
+destructing int: 1001
+destructing int: 0
+destructing int: 0
+destructing int: 1001
+construct b.a1
+constructing int
+constructing int
+begin construct A
+construct a.x
 constructing int: 1000
 assign a->y
+assign a.y
 assigning int: 0 0
 end construct A
 …
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
+copy construct this.x
 copy constructing int: 1000
 assign this->y
 copy constructing int: 0
 destructing int: 0
 destructing int: 0
 end copy construct A
 copy constructing int: 0
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 1001
 assign this->y
 copy constructing int: 0
 destructing int: 0
 destructing int: 0
 end copy construct A
 copy constructing int: 0
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 0
 assign this->y
+assign this.y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this.x
+copy constructing int: 1001
+assign this.y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this.x
+copy constructing int: 0
+assign this.y
 copy constructing int: 0
 destructing int: 0
 …
 constructing int
 begin construct A
 construct a->x
+construct a.x
 constructing int: 999
 assign a->y
 assigning int: 0 0
 end construct A
 copy constructing int: 0
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 999
 assign this->y
+assign a.y
+assigning int: 0 0
+end construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this.x
+copy constructing int: 999
+assign this.y
 copy constructing int: 0
 destructing int: 0
 …
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 999
 assign this->y
+copy construct this.x
+copy constructing int: 999
+assign this.y
 copy constructing int: 0
 destructing int: 0
 …
 constructing int
 begin construct A
 construct a->x
+construct a.x
 constructing int: 999
 assign a->y
 assigning int: 0 0
 end construct A
 copy constructing int: 0
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 999
 assign this->y
+assign a.y
+assigning int: 0 0
+end construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this.x
+copy constructing int: 999
+assign this.y
 copy constructing int: 0
 destructing int: 0
 …
 copy constructing int: 0
 begin copy construct A
 copy construct this->x
 copy constructing int: 999
 assign this->y
+copy construct this.x
+copy constructing int: 999
+assign this.y
 copy constructing int: 0
 destructing int: 0

src/tests/alloc.c

-              raf08051
+              r28e58fd
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
 //
 …
 // file "LICENCE" distributed with Cforall.
 //
 // alloc.c --
 //
+// alloc.c --
+//
 // Author           : Peter A. Buhr
 // Created On       : Wed Feb  3 07:56:22 2016
 …
 // Last Modified On : Thu Jul 20 16:01:10 2017
 // Update Count     : 318
 //
+//
 #include <assert.h>
 …
 #include <stdlib.h>                                                                             // posix_memalign
 #include <fstream>
 #include <stdlib>                                                                               // access C malloc, realloc
+#include <stdlib>                                                                                       // access C malloc, realloc
 int * foo( int * p, int c ) { return p; }
 …
 int main( void ) {
     size_t dim = 10;
     int * p;
+        size_t dim = 10;
+        int * p;
         char fill = '\1';
         // allocation, non-array types
     p = (void *)malloc( sizeof(*p) );                                   // C malloc, type unsafe
+        p = (void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
         *p = 0xdeadbeef;
         printf( "C   malloc %#x\n", *p );
     free( p );
     p = malloc();                                                                               // CFA malloc, type safe
+        free( p );
+        p = malloc();                                       // CFA malloc, type safe
         *p = 0xdeadbeef;
         printf( "CFA malloc %#x\n", *p );
     free( p );
     p = alloc();                                                                                // CFA alloc, type safe
+        free( p );
+        p = alloc();                                        // CFA alloc, type safe
         *p = 0xdeadbeef;
         printf( "CFA alloc %#x\n", *p );
     free( p );
     p = alloc( fill );                                                                  // CFA alloc, fill
+        free( p );
+        p = alloc( fill );                                  // CFA alloc, fill
         printf( "CFA alloc, fill %08x\n", *p );
 …
         printf( "\n" );
     p = calloc( dim, sizeof( *p ) );                                    // C array calloc, type unsafe
+        p = calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
         printf( "C   array calloc, fill 0\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
     free( p );
     p = calloc( dim );                                                                  // CFA array calloc, type safe
+        free( p );
+        p = calloc( dim );                                  // CFA array calloc, type safe
         printf( "CFA array calloc, fill 0\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
     free( p );
     p = alloc( dim );                                                                   // CFA array alloc, type safe
+        free( p );
+        p = alloc( dim );                                   // CFA array alloc, type safe
         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
         printf( "CFA array alloc, no fill\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
     free( p );
     p = alloc( 2 * dim, fill );                                                 // CFA array alloc, fill
+        free( p );
+        p = alloc( 2 * dim, fill );                         // CFA array alloc, fill
         printf( "CFA array alloc, fill %#x\n", fill );
         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
 …
         printf( "\n" );
     p = (void *)realloc( p, dim * sizeof(*p) );                 // C realloc
+        p = (void *)realloc( p, dim * sizeof(*p) );         // C realloc
         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
         printf( "C   realloc\n" );
 …
         printf( "\n" );
     p = realloc( p, 2 * dim * sizeof(*p) );                             // CFA realloc
+        p = realloc( p, 2 * dim * sizeof(*p) );             // CFA realloc
         for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
         printf( "CFA realloc\n" );
 …
         printf( "\n" );
     p = alloc( p, dim );                                                                // CFA resize array alloc
+        p = alloc( p, dim );                                // CFA resize array alloc
         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
         printf( "CFA resize alloc\n" );
 …
         printf( "\n" );
     p = alloc( p, 2 * dim );                                                    // CFA resize array alloc
+        p = alloc( p, 2 * dim );                            // CFA resize array alloc
         for ( int i = dim; i < 2 * dim; i += 1 ) { p[i] = 0x1010101; }
         printf( "CFA resize array alloc\n" );
 …
         printf( "\n" );
     p = alloc( p, dim );                                                                // CFA array alloc
+        p = alloc( p, dim );                                // CFA array alloc
         printf( "CFA resize array alloc\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
 …
         p = 0;
     p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
+        p = alloc( p, dim, fill );                          // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
     p = alloc( p, 2 * dim, fill );                                              // CFA array alloc, fill
+        p = alloc( p, 2 * dim, fill );                      // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
         for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); }
         printf( "\n" );
     p = alloc( p, dim, fill );                                                  // CFA array alloc, fill
+        p = alloc( p, dim, fill );                          // CFA array alloc, fill
         printf( "CFA resize array alloc, fill\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] );; }
 …
     struct Struct { int x; double y; };
     Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
+        struct Struct { int x; double y; };
+        Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
         // alignment, non-array types
 …
         enum { Alignment = 128 };
     stp = (memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
+        stp = &(*(Struct*)memalign( Alignment, sizeof( *stp ) ) ){ 42, 42.5 }; // C memalign
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "C   memalign %d %g\n", stp->x, stp->y );
     free( stp );
     stp = (memalign( Alignment )){ 42, 42.5 };                  // CFA memalign
+        free( stp );
+        stp = &(*memalign( Alignment )){ 42, 42.5 };          // CFA memalign
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA memalign %d %g\n", stp->x, stp->y );
     free( stp );
     posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
+        free( stp );
+        posix_memalign( (void **)&stp, Alignment, sizeof( *stp ) ); // C posix_memalign
         *stp = (Struct){ 42, 42.5 };
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
     free( stp );
     posix_memalign( &stp, Alignment );                                  // CFA posix_memalign
+        free( stp );
+        posix_memalign( &stp, Alignment );                  // CFA posix_memalign
         *stp = (Struct){ 42, 42.5 };
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA posix_memalign %d %g\n", stp->x, stp->y );
     free( stp );
     stp = (aligned_alloc( Alignment )){ 42, 42.5 };             // CFA aligned_alloc
+        free( stp );
+        stp = &(*aligned_alloc( Alignment )){ 42, 42.5 };     // CFA aligned_alloc
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA aligned_alloc %d %g\n", stp->x, stp->y );
     free( stp );
     stp = (align_alloc( Alignment )){ 42, 42.5 };               // CFA align_alloc
+        free( stp );
+        stp = &(*align_alloc( Alignment )){ 42, 42.5 };       // CFA align_alloc
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA align_alloc %d %g\n", stp->x, stp->y );
     free( stp );
     stp = align_alloc( Alignment, fill );                               // CFA memalign, fill
+        free( stp );
+        stp = align_alloc( Alignment, fill );               // CFA memalign, fill
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA align_alloc fill %#x %a\n", stp->x, stp->y );
     free( stp );
+        free( stp );
 …
         printf( "\n" );
     stp = align_alloc( Alignment, dim );                                // CFA array memalign
+        stp = align_alloc( Alignment, dim );                // CFA array memalign
         assert( (uintptr_t)stp % Alignment == 0 );
         for ( int i = 0; i < dim; i += 1 ) { stp[i] = (Struct){ 42, 42.5 }; }
 …
         for ( int i = 0; i < dim; i += 1 ) { printf( "%d %g, ", stp[i].x, stp[i].y ); }
         printf( "\n" );
     free( stp );
     stp = align_alloc( Alignment, dim, fill );                  // CFA array memalign, fill
+        free( stp );
+        stp = align_alloc( Alignment, dim, fill );          // CFA array memalign, fill
         assert( (uintptr_t)stp % Alignment == 0 );
         printf( "CFA array align_alloc, fill\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", stp[i].x, stp[i].y ); }
         printf( "\n" );
     free( stp );
+        free( stp );
 …
         printf( "\n" );
     memset( &st, fill );                                                                // CFA memset, type safe
+        memset( &st, fill );                                // CFA memset, type safe
         printf( "CFA memset %#x %a\n", st.x, st.y );
     memcpy( &st1, &st );                                                                // CFA memcpy, type safe
+        memcpy( &st1, &st );                                // CFA memcpy, type safe
         printf( "CFA memcpy %#x %a\n", st1.x, st1.y );
 …
         printf( "\n" );
     memset( sta, dim, fill );                                                   // CFA array memset, type safe
+        memset( sta, dim, fill );                           // CFA array memset, type safe
         printf( "CFA array memset\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta[i].x, sta[i].y ); }
         printf( "\n" );
     memcpy( sta1, sta, dim );                                                   // CFA array memcpy, type safe
+        memcpy( sta1, sta, dim );                           // CFA array memcpy, type safe
         printf( "CFA memcpy\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x %a, ", sta1[i].x, sta1[i].y ); }
 …
         printf( "\n" );
     float * fp = malloc() + 1;
     printf( "pointer arithmetic %d\n", fp == fp - 1 );
     free( fp - 1 );
     p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
+        float * fp = malloc() + 1;
+        printf( "pointer arithmetic %d\n", fp == fp - 1 );
+        free( fp - 1 );
+        p = foo( bar( baz( malloc(), 0 ), 0 ), 0 );
         *p = 0xdeadbeef;
         printf( "CFA deep malloc %#x\n", *p );
     free( p );
+        free( p );
         stp = malloc();
         printf( "\nSHOULD FAIL\n" );
     p = alloc( stp, dim * sizeof(*stp) );
     p = memset( stp, 10 );
     p = memcpy( &st1, &st );
+        p = alloc( stp, dim * sizeof(*stp) );
+        p = memset( stp, 10 );
+        p = memcpy( &st1, &st );
 } // main

src/tests/avltree/avl.h

-              raf08051
+              r28e58fd
 // xxx - unbound type variable problems when trying to use new instead of create
 // forall( otype T, ttype Params | { void ?{}(T *, Params); } ) T * new( Params p );
-forall(dtype T | { void ^?{}(T *); })
-void delete(T * x);
 // To-do: properly use height or balance factor
 …
 forall(otype K | Comparable(K), otype V)
 void ?{}(tree(K, V) *t, K key, V value);
+void ?{}(tree(K, V) &t, K key, V value);
 forall(otype K, otype V)
 void ^?{}(tree(K, V) * t);
+void ^?{}(tree(K, V) & t);
 forall(otype K | Comparable(K), otype V)

src/tests/avltree/avl1.c

-              raf08051
+              r28e58fd
 #include "avl.h"
 // #include "cwrap.h"
+#include <stdlib>
 forall(otype K | Comparable(K), otype V)
 void ?{}(tree(K, V) *t, K key, V value){
   (&t->key) { key };
   (&t->value) { value };
   t->parent = NULL;
   t->left = NULL;
   t->right = NULL;
   t->balance = 0;
+void ?{}(tree(K, V) &t, K key, V value){
+  (t.key) { key };
+  (t.value) { value };
+  t.parent = NULL;
+  t.left = NULL;
+  t.right = NULL;
+  t.balance = 0;
+}
 forall(otype K, otype V)
 void ^?{}(tree(K, V) * t){
   delete(t->left);
   delete(t->right);
   ^(&t->key){};
   ^(&t->value){};
+void ^?{}(tree(K, V) & t){
+  delete(t.left);
+  delete(t.right);
+  ^(t.key){};
+  ^(t.value){};
+}
 …
   // infinite loop trying to resolve ... t = malloc();
   tree(K, V) * t = malloc(sizeof(tree(K,V)));
   t { key, value };
+  (*t){ key, value };
   return t;
+}

src/tests/avltree/avl3.c

-              raf08051
+              r28e58fd
 #include "avl.h"
 #include "avl-private.h"
+// from stdlib
+forall(otype T)
+void swap(T *, T *);
+#include <stdlib>
 // swaps the data within two tree nodes
 forall(otype K | Comparable(K), otype V)
 void node_swap(tree(K, V) * t, tree(K, V) * t2){
   swap(&t->key, &t2->key);
   swap(&t->value, &t2->value);
+        swap( t->key,  t2->key);
+        swap( t->value, t2->value);
+}
 …
 forall(otype K | Comparable(K), otype V)
 tree(K, V) * find_successor(tree(K, V) * t){
   tree(K, V) * find_successor_helper(tree(K, V) * t){
     // go left as deep as possible, return the last node
     if (empty(t->left)){
       return t;
     } else {
       return find_successor_helper(t->left);
+    }
+  }
   return find_successor_helper(t->right);
+        tree(K, V) * find_successor_helper(tree(K, V) * t){
+                // go left as deep as possible, return the last node
+                if (empty(t->left)){
+                        return t;
+                } else {
+                        return find_successor_helper(t->left);
+                }
+        }
+        return find_successor_helper(t->right);
+}
 …
 forall(otype K | Comparable(K), otype V)
 void deleteSingleNode(tree(K, V) * t) {
   t->left = NULL;
   t->right = NULL;
   deleteSingleNode(t);
+        t->left = NULL;
+        t->right = NULL;
+        delete(t);
+}
 …
 forall(otype K | Comparable(K), otype V)
 tree(K, V) * remove_node(tree(K, V) * t){
   // is the node a leaf?
   if (empty(t->left) && empty(t->right)){
     // yes, just delete this node
     delete(t);
     return NULL;
   } else if (empty(t->left)){
     // if the left is empty, there is only one child -> move right up
     node_swap(t, t->right);
     tree(K, V) * tmp = t->right;
+        // is the node a leaf?
+        if (empty(t->left) && empty(t->right)){
+                // yes, just delete this node
+                delete(t);
+                return NULL;
+        } else if (empty(t->left)){
+                // if the left is empty, there is only one child -> move right up
+                node_swap(t, t->right);
+                tree(K, V) * tmp = t->right;
     // relink tree
     t->left = tmp->left;
     t->right = tmp->right;
+                // relink tree
+                t->left = tmp->left;
+                t->right = tmp->right;
     setParent(t->left, t);
     setParent(t->right, t);
     deleteSingleNode(tmp);
     return t;
   } else if (empty(t->right)){
     // if the right is empty, there is only one child -> move left up
     node_swap(t, t->left);
     tree(K, V) * tmp = t->left;
+                setParent(t->left, t);
+                setParent(t->right, t);
+                deleteSingleNode(tmp);
+                return t;
+        } else if (empty(t->right)){
+                // if the right is empty, there is only one child -> move left up
+                node_swap(t, t->left);
+                tree(K, V) * tmp = t->left;
     // relink tree
     t->left = tmp->left;
     t->right = tmp->right;
+                // relink tree
+                t->left = tmp->left;
+                t->right = tmp->right;
     setParent(t->left, t);
     setParent(t->right, t);
     deleteSingleNode(tmp);
     return t;
   } else {
     // swap with the successor
     tree(K, V) * s = find_successor(t);
     tree(K, V) * parent = s->parent;
+                setParent(t->left, t);
+                setParent(t->right, t);
+                deleteSingleNode(tmp);
+                return t;
+        } else {
+                // swap with the successor
+                tree(K, V) * s = find_successor(t);
+                tree(K, V) * parent = s->parent;
     if (parent->left == s){
       parent->left = s->right;
     } else {
       assert(parent->right == s);
       parent->right = s->right;
+    }
     setParent(s->right, parent);
     node_swap(t, s);
     deleteSingleNode(s);
     return t;
+  }
+                if (parent->left == s){
+                        parent->left = s->right;
+                } else {
+                        assert(parent->right == s);
+                        parent->right = s->right;
+                }
+                setParent(s->right, parent);
+                node_swap(t, s);
+                deleteSingleNode(s);
+                return t;
+        }
+}
 …
 forall(otype K | Comparable(K), otype V)
 tree(K, V) * remove_helper(tree(K, V) * t, K key, int * worked){
   if (empty(t)){
     // did not work because key was not found
     // set the status variable and return
     *worked = 1;
   } else if (t->key == key) {
     t = remove_node(t);
   } else if (t->key < key){
     t->right = remove_helper(t->right, key, worked);
   } else {
     // t->key > key
     t->left = remove_helper(t->left, key, worked);
+  }
   // try to fix after deleting
   if (! empty(t)) {
     t = tryFix(t);
+  }
   return t;
+        if (empty(t)){
+                // did not work because key was not found
+                // set the status variable and return
+                *worked = 1;
+        } else if (t->key == key) {
+                t = remove_node(t);
+        } else if (t->key < key){
+                t->right = remove_helper(t->right, key, worked);
+        } else {
+                // t->key > key
+                t->left = remove_helper(t->left, key, worked);
+        }
+        // try to fix after deleting
+        if (! empty(t)) {
+                t = tryFix(t);
+        }
+        return t;
+}
 forall(otype K | Comparable(K), otype V)
 int remove(tree(K, V) ** t, K key){
   int worked = 0;
   tree(K, V) * newTree = remove_helper(*t, key, &worked);
   *t = newTree;
   return worked;
+        int worked = 0;
+        tree(K, V) * newTree = remove_helper(*t, key, &worked);
+        *t = newTree;
+        return worked;
+}
+// Local Variables: //
+// tab-width: 4 //
+// End: //

src/tests/avltree/avl_test.c

raf08051	r28e58fd
1	1	#include "avl.h"
2	2	#include "avl-private.h"
	3	#include <stdlib>
3	4
4	5	extern "C" {

src/tests/coroutine.c

-              raf08051
+              r28e58fd
 //
+//
 // Cforall Version 1.0.0 Copyright (C) 2017 University of Waterloo
 //
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
 //
 // fibonacci.c --
 //
+//
+// fibonacci.c --
+//
 // Author           : Thierry Delisle
 // Created On       : Thu Jun  8 07:29:37 2017
 …
 // Last Modified On : Thu Jun  8 07:37:12 2017
 // Update Count     : 5
 //
+//
 #include <fstream>
 …
 };
 void ?{}( Fibonacci * this ) {
         this->fn = 0;
+void ?{}( Fibonacci & this ) {
+        this.fn = 0;
+}
 void main( Fibonacci * this ) {
+void main( Fibonacci & this ) {
         int fn1, fn2;                                   // retained between resumes
         this->fn = 0;                                   // case 0
         fn1 = this->fn;
+        this.fn = 0;                                    // case 0
+        fn1 = this.fn;
         suspend();                                              // return to last resume
         this->fn = 1;                                   // case 1
+        this.fn = 1;                                    // case 1
         fn2 = fn1;
         fn1 = this->fn;
+        fn1 = this.fn;
         suspend();                                              // return to last resume
         for ( ;; ) {                                    // general case
                 this->fn = fn1 + fn2;
+                this.fn = fn1 + fn2;
                 fn2 = fn1;
                 fn1 = this->fn;
+                fn1 = this.fn;
                 suspend();                                      // return to last resume
         } // for
+}
 int next( Fibonacci * this ) {
+int next( Fibonacci & this ) {
         resume( this );                                 // transfer to last suspend
         return this->fn;
+        return this.fn;
+}
 …
         Fibonacci f1, f2;
         for ( int i = 1; i <= 10; i += 1 ) {
                 sout | next( &f1 ) | ' ' | next( &f2 ) | endl;
+                sout | next( f1 ) | ' ' | next( f2 ) | endl;
         } // for
+}

src/tests/dtor-early-exit.c

-              raf08051
+              r28e58fd
 // don't want these called
 void ?{}(A * a) { assert( false ); }
 void ?{}(A * a, const char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
 void ?{}(A * a, const char * name, int * ptr) { assert( false ); }
 A ?=?(A * a, A a) {  sout | "assign " | a->name | " " | a.name; return a; }
 void ?{}(A * a, A a) { sout | "copy construct " | a.name | endl; a->x = (int*)malloc(); }
 void ^?{}(A * a) { sout | "destruct " | a->name | endl; free(a->x); }
+void ?{}(A & a) { assert( false ); }
+void ?{}(A & a, const char * name) { a.name = name; sout | "construct " | name | endl; a.x = (int*)malloc(); }
+void ?{}(A & a, const char * name, int * ptr) { assert( false ); }
+A ?=?(A & a, A b) {  sout | "assign " | a.name | " " | b.name; return a; }
+void ?{}(A & a, A b) { sout | "copy construct " | b.name | endl; a.x = (int*)malloc(); }
+void ^?{}(A & a) { sout | "destruct " | a.name | endl; free(a.x); }
 // test returns

src/tests/fstream_test.c

-              raf08051
+              r28e58fd
 // fstream_test.c --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon May  2 15:25:54 2016
 // Update Count     : 61
+// Last Modified On : Thu Aug 24 11:30:26 2017
+// Update Count     : 65
 //
 …
         int nombre;
         sout | "Entrez un nombre, s'il vous plaît:" | endl;
+        sin  | &nombre;
+        sout | "Vous avez entré" | nombre | "stocké à l'adresse" | &nombre | endl;
+        sout | "nombre" | nombre | "est"
+                 | (nombre > 0 ? "plus grand que" : nombre == 0 ? "égal à" : "moins de")
+                 | "zéro" | endl;
+        sin  | nombre;
+        sout | "Vous avez entré" | nombre | endl;
+        sout | "le nombre" | nombre | "est"
+                 | (nombre > 0 ? "positif" : nombre == 0 ? "zéro" : "négatif") | endl;
         sout | "Entrez trois nombres, s'il vous plaît: " | endl;
         int i, j, k;
         sin  | &i | &j | &k;
+        sin  | i | j | k;
         sout | "Vous avez entré" | "i:" | "" | i | "j:" | "" | j | "k:" | "" | k | endl;
+}

src/tests/globals.c

-              raf08051
+              r28e58fd
 };
 void ?{}( value_t * this ) { this->value = 22; }
+void ?{}( value_t & this ) { this.value = 22; }
 //Standard case
 …
 };
 void ?{}( g_t * this ) { (&this->val){}; }
+void ?{}( g_t & this ) { (this.val){}; }
 g_t g;
 …
 //Inline case
 struct gi_t;
 void ?{}( gi_t * this );
+void ?{}( gi_t & this );
 struct gi_t {
 …
 } gi;
 void ?{}( gi_t * this ) { (&this->val){}; }
+void ?{}( gi_t & this ) { (this.val){}; }
 //Inline autogen case
 …
 };
 void ?{}( gs_t * this ) { (&this->val){}; }
+void ?{}( gs_t & this ) { (this.val){}; }
 static gs_t gs;
 …
 //Static inline case
 struct gsi_t;
 void ?{}( gsi_t * this );
+void ?{}( gsi_t & this );
 static struct gsi_t {
 …
 } gsi;
 void ?{}( gsi_t * this ) { (&this->val){}; }
+void ?{}( gsi_t & this ) { (this.val){}; }
 //Static inline autogen case

src/tests/gmp.c

-              raf08051
+              r28e58fd
 // Created On       : Tue Apr 19 08:55:51 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 13 16:35:01 2017
 // Update Count     : 541
+// Last Modified On : Thu Aug 24 09:33:26 2017
+// Update Count     : 543
 //
 …
         sout | endl;
+        sin | x | y | z;
+        sout | x | y | z | endl;
+        sout | endl;
         sout | "Fibonacci Numbers" | endl;
         Int fn, fn1, fn2;

src/tests/init_once.c

-              raf08051
+              r28e58fd
         return -1;
+}
 void ?{}(array * arr) {
         memset(arr->elems, 0, sizeof(arr->elems));
         arr->length = 0;
+void ?{}(array & arr) {
+        memset(arr.elems, 0, sizeof(arr.elems));
+        arr.length = 0;
+}
 array constructed;
 array destructed;
 void ?{}(init_once * x) {
         assert( find( &constructed, x ) == -1 );
         remove( &destructed, x );
         insert( &constructed, x );
+void ?{}(init_once & x) {
+        assert( find( &constructed, &x ) == -1 );
+        remove( &destructed, &x );
+        insert( &constructed, &x );
         x->x = malloc(sizeof(int));
+        x.x = malloc(sizeof(int));
+}
 void ?{}(init_once * x, init_once other) {
+void ?{}(init_once & x, init_once other) {
         x{};  // reuse default ctor
+}
 void ^?{}(init_once * x) {
         assert( find( &destructed, x ) == -1 );
         remove( &constructed, x );
         insert( &destructed, x );
+void ^?{}(init_once & x) {
+        assert( find( &destructed, &x ) == -1 );
+        remove( &constructed, &x );
+        insert( &destructed, &x );
         free(x->x);
+        free(x.x);
+}
 //*** end setup
 …
                                 init_once x;
                                 init_once y = x;
                                 (&x) {}; // ensure this doesn't execute
+                                x{}; // ensure this doesn't execute
                                 break;
+                        }

src/tests/io.c

-              raf08051
+              r28e58fd
 // Created On       : Wed Mar  2 16:56:02 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul  6 23:26:12 2017
 // Update Count     : 78
+// Last Modified On : Wed Aug 23 21:27:50 2017
+// Update Count     : 79
 //
 …
         sout | "input bacis types" | endl;
         &in | &c                                                                                        // character
                 | &si | &usi | &i | &ui | &li | &uli | &lli | &ulli     // integral
                 | &f | &d | &ld                                                                 // floating point
                 | &fc | &dc | &ldc                                                              // floating-point complex
+        &in | c                                                                                         // character
+                | si | usi | i | ui | li | uli | lli | ulli             // integral
+                | f | d | ld                                                                    // floating point
+                | fc | dc | ldc                                                                 // floating-point complex
                 | cstr( s1 ) | cstr( s2, size );                                // C string, length unchecked and checked
         sout | endl;

src/tests/memberCtors.c

-              raf08051
+              r28e58fd
 };
 void ?{}(WrappedInt * this) {
+void ?{}(WrappedInt & this) {
   printf("constructing int\n");
   this->x = 0;
+  this.x = 0;
+}
 void ?{}(WrappedInt * this, WrappedInt other) {
+void ?{}(WrappedInt & this, WrappedInt other) {
   printf("copy constructing int: %d\n", other.x);
   this->x = other.x;
+  this.x = other.x;
+}
 void ?{}(WrappedInt * this, int x) {
+void ?{}(WrappedInt & this, int x) {
   printf("constructing int: %d\n", x);
   this->x = x;
+  this.x = x;
+}
 void ^?{}(WrappedInt * this) {
   printf("destructing int: %d\n", this->x);
+void ^?{}(WrappedInt & this) {
+  printf("destructing int: %d\n", this.x);
+}
 void ?=?(WrappedInt * this, int x) {
   printf("assigning int: %d %d\n", this->x, x);
   this->x = x;
+void ?=?(WrappedInt & this, int x) {
+  printf("assigning int: %d %d\n", this.x, x);
+  this.x = x;
+}
 …
 };
 void ?{}(A * a) {
+void ?{}(A & a) {
   // currently must define default ctor, since there's no "= default" syntax
+}
 void ?{}(A * a, int x) {
+void ?{}(A & a, int x) {
   printf("begin construct A\n");
   printf("construct a->x\n");
   (&a->x){ x+999 };
   printf("assign a->y\n");
   a->y = 0; // not a constructor - default constructor will be inserted
+  printf("construct a.x\n");
+  (a.x){ x+999 };
+  printf("assign a.y\n");
+  a.y = 0; // not a constructor - default constructor will be inserted
   printf("end construct A\n");
 } // z never constructed - will be automatically default constructed
 void ?{}(A * this, A other) {
+void ?{}(A & this, A other) {
   printf("begin copy construct A\n");
   printf("copy construct this->x\n");
   (&this->x){ other.x };
   printf("assign this->y\n");
   this->y = other.y; // not a constructor - copy constructor will be inserted
+  printf("copy construct this.x\n");
+  (this.x){ other.x };
+  printf("assign this.y\n");
+  this.y = other.y; // not a constructor - copy constructor will be inserted
   printf("end copy construct A\n");
 } // z never constructed - will be automatically copy constructed
 A ?=?(A * this, A other) {
+A ?=?(A & this, A other) {
   printf("begin ?=? A\n");
   this->x = other.x;
   this->y = other.y;
   this->z = other.z;
+  this.x = other.x;
+  this.y = other.y;
+  this.z = other.z;
   printf("end ?=? A\n");
   return *this;
+  return this;
+}
 …
 };
 void ?{}(B * b) {
+void ?{}(B & b) {
   printf("begin construct B\n");
   printf("assign b->a2\n");
   b->a2 = (A) { 2 };
   printf("construct b->a1\n");
   (&b->a1){ 1 };
+  printf("assign b.a2\n");
+  b.a2 = (A) { 2 };
+  printf("construct b.a1\n");
+  (b.a1){ 1 };
 #ifdef ERR1
   (&b->a2){ b->a3 }; // error, b->a2 was used previously but is explicitly constructed
+  (b.a2){ b.a3 }; // error, b->a2 was used previously but is explicitly constructed
 #endif
   printf("end construct B\n");
 } // a2, a3 never constructed - will be automatically default constructed
 void ^?{}(B * b) {
   b->a2 = (A) { 0 };
   ^(&b->a1){};
+void ^?{}(B & b) {
+  b.a2 = (A) { 0 };
+  ^(b.a1){};
 } // a2, a3 never destructed - will be automatically destructed

src/tests/monitor.c

-              raf08051
+              r28e58fd
 };
 void ?{}(global_t * this) {
         this->value = 0;
+void ?{}(global_t & this) {
+        this.value = 0;
+}
 static global_t global;
 void increment3( global_t * mutex this ) {
         this->value += 1;
+void increment3( global_t & mutex this ) {
+        this.value += 1;
+}
 void increment2( global_t * mutex this ) {
+void increment2( global_t & mutex this ) {
         increment3( this );
+}
 void increment( global_t * mutex this ) {
+void increment( global_t & mutex this ) {
         increment2( this );
+}
 …
 thread MyThread {};
 void main( MyThread* this ) {
+void main( MyThread & this ) {
         for(int i = 0; i < 1_000_000; i++) {
                 increment( &global );
+                increment( global );
+        }
+}

src/tests/multi-monitor.c

-              raf08051
+              r28e58fd
 static monitor_t m1, m2, m3;
 void increment( monitor_t * mutex p1, monitor_t * mutex p2, int * value ) {
         *value += 1;
+void increment( monitor_t & mutex p1, monitor_t & mutex p2, int & value ) {
+        value += 1;
+}
+struct MyThread {
+        thread_desc __thrd;
+thread MyThread {
         int target;
 };
+DECL_THREAD(MyThread);
+void ?{}( MyThread * this, int target ) {
+        this->target = target;
+void ?{}( MyThread & this, int target ) {
+        this.target = target;
+}
 void ^?{}( MyThread * mutex this ) {}
+void ^?{}( MyThread & mutex this ) {}
 void main( MyThread* this ) {
+void main( MyThread & this ) {
         for(int i = 0; i < 1000000; i++) {
                 choose(this->target) {
                         case 0: increment( &m1, &m2, &global12 );
                         case 1: increment( &m2, &m3, &global23 );
                         case 2: increment( &m1, &m3, &global13 );
+                choose(this.target) {
+                        case 0: increment( m1, m2, global12 );
+                        case 1: increment( m2, m3, global23 );
+                        case 2: increment( m1, m3, global13 );
+                }
+        }
+}
+forall(dtype T | sized(T) | { void ^?{}(T & mutex); })
+void delete_mutex(T * x) {
+        ^(*x){};
+        free(x);
+}
 …
         processor p;
+        {
                 scoped(MyThread) * f[6];
+                MyThread * f[6];
                 for(int i = 0; i < 6; i++) {
                         f[i] = ((scoped(MyThread) *)malloc()){ i % 3 };
+                        f[i] = new(i % 3);
+                }
                 for(int i = 0; i < 6; i++) {
                         delete( f[i] );
+                        delete_mutex( f[i] );
+                }
+        }

src/tests/multiDimension.c

-              raf08051
+              r28e58fd
 };
 void ?{}(X * this) {
+void ?{}(X & this) {
   printf("default constructing\n");
   (&this->a){ 123 };
   this->ptr = malloc(sizeof(int));
+  (this.a){ 123 };
+  this.ptr = malloc(sizeof(int));
+}
 void ?{}(X * this, X other) {
+void ?{}(X & this, X other) {
   printf("copy constructing\n");
   (&this->a){ other.a };
   this->ptr = malloc(sizeof(int));
+  (this.a){ other.a };
+  this.ptr = malloc(sizeof(int));
+}
 void ?{}(X * this, int a) {
+void ?{}(X & this, int a) {
   printf("constructing with %d\n", a);
   (&this->a){ a };
   this->ptr = malloc(sizeof(int));
+  (this.a){ a };
+  this.ptr = malloc(sizeof(int));
+}
 void ^?{}(X * this) {
+void ^?{}(X & this) {
   printf("destructing\n");
   free(this->ptr);
+  free(this.ptr);
+}
 X ?=?(X * this, X other) {
   this->a = other.a;
   return *this;
+X ?=?(X & this, X other) {
+  this.a = other.a;
+  return this;
+}

src/tests/operators.c

raf08051	r28e58fd
11	11	}
12	12
13		int ?=?( int *a, int b ) {
	13	int ?=?( int &a, int b ) {
14	14	return 0;
15	15	}

src/tests/preempt.c

-              raf08051
+              r28e58fd
 };
 void ?{}( worker_t * this, int value ) {
         this->value = value;
+void ?{}( worker_t & this, int value ) {
+        this.value = value;
+}
 void main(worker_t * this) {
+void main(worker_t & this) {
         while(counter < 1000) {
                 if( (counter % 7) == this->value ) {
+                if( (counter % 7) == this.value ) {
                         int next = __atomic_add_fetch_4(&counter, 1, __ATOMIC_SEQ_CST);
                         if( (next % 100) == 0 ) printf("%d\n", next);

src/tests/rational.c

-              raf08051
+              r28e58fd
 //
+//
 // 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.
 //
+//
 // rational.c -- test rational number package
 //
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Mar 28 08:43:12 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed May 17 15:46:35 2017
 // Update Count     : 65
 //
+// Last Modified On : Wed Aug 23 21:40:11 2017
+// Update Count     : 66
+//
 #include <rational>
 …
 // UNNECESSARY, FIX ME
 void ?{}( int * this ) { *this = 0; }
 void ?{}( int * this, zero_t ) { *this = 0; }
 void ?{}( int * this, one_t ) { *this = 1; }
+void ?{}( int & this ) { this = 0; }
+void ?{}( int & this, zero_t ) { this = 0; }
+void ?{}( int & this, one_t ) { this = 1; }
 double convert( int i ) { return (double)i; }
 int convert( double d ) { return (int)d; }
 …
         sout | x | endl;
         sin | &a | &b;
+        sin | a | b;
         sout | a | b | endl;
 } // main

src/tests/sched-int-barge.c

-              raf08051
+              r28e58fd
 };
 void ?{} ( global_data_t * this ) {
         this->done = false;
         this->counter = 0;
         this->state = BARGE;
+void ?{} ( global_data_t & this ) {
+        this.done = false;
+        this.counter = 0;
+        this.state = BARGE;
         this->do_signal = 6;
         this->do_wait1  = 1;
         this->do_wait2  = 3;
+        this.do_signal = 6;
+        this.do_wait1  = 1;
+        this.do_wait2  = 3;
+}
 void ^?{} ( global_data_t * this ) {}
+void ^?{} ( global_data_t & this ) {}
 global_t globalA;
 …
 thread Threads {};
 bool logicC( global_t * mutex a, global_t * mutex b, global_data_t * mutex c ) {
         c->counter++;
+bool logicC( global_t & mutex a, global_t & mutex b, global_data_t & mutex c ) {
+        c.counter++;
         if( (c->counter % 1000) == 0 ) sout | c->counter | endl;
+        if( (c.counter % 1000) == 0 ) sout | c.counter | endl;
         int action = c->counter % 10;
+        int action = c.counter % 10;
         if( action == 0 ) {
                 c->do_signal = max( ((unsigned)rand48()) % 10, 1);
                 c->do_wait1 = ((unsigned)rand48()) % (c->do_signal);
                 c->do_wait2 = ((unsigned)rand48()) % (c->do_signal);
+                c.do_signal = max( ((unsigned)rand48()) % 10, 1);
+                c.do_wait1 = ((unsigned)rand48()) % (c.do_signal);
+                c.do_wait2 = ((unsigned)rand48()) % (c.do_signal);
                 if(c->do_wait1 == c->do_wait2) sout | "Same" | endl;
+                if(c.do_wait1 == c.do_wait2) sout | "Same" | endl;
+        }
         if( action == c->do_wait1 || action == c->do_wait2 ) {
                 c->state = WAIT;
+        if( action == c.do_wait1 || action == c.do_wait2 ) {
+                c.state = WAIT;
                 wait( &cond );
                 if(c->state != SIGNAL) {
                         sout | "ERROR Barging detected" | c->counter | endl;
+                if(c.state != SIGNAL) {
+                        sout | "ERROR Barging detected" | c.counter | endl;
                         abort();
+                }
+        }
         else if( action == c->do_signal ) {
                 c->state = SIGNAL;
+        else if( action == c.do_signal ) {
+                c.state = SIGNAL;
                 signal( &cond );
 …
+        }
         else {
                 c->state = BARGE;
+                c.state = BARGE;
+        }
         if( c->counter >= N ) c->done = true;
         return !c->done;
+        if( c.counter >= N ) c.done = true;
+        return !c.done;
+}
 bool logicB( global_t * mutex a, global_t * mutex b ) {
         return logicC(a, b, &globalC);
+bool logicB( global_t & mutex a, global_t & mutex b ) {
+        return logicC(a, b, globalC);
+}
 bool logicA( global_t * mutex a ) {
         return logicB(a, &globalB);
+bool logicA( global_t & mutex a ) {
+        return logicB(a, globalB);
+}
 void main( Threads* this ) {
         while( logicA(&globalA) ) { yield(); };
+void main( Threads & this ) {
+        while( logicA(globalA) ) { yield(); };
+}
 …
 int main(int argc, char* argv[]) {
         rand48seed(0);
         processor p;
+        {
                 Threads t[17];
                 the_threads = (thread_desc*)t;
+        }
+        rand48seed(0);
+        processor p;
+        {
+                Threads t[17];
+                the_threads = (thread_desc*)t;
+        }
+}

src/tests/sched-int-block.c

-              raf08051
+              r28e58fd
 };
 void ?{} ( global_data_t * this ) {
         this->last_thread = NULL;
         this->last_signaller = NULL;
+void ?{} ( global_data_t & this ) {
+        this.last_thread = NULL;
+        this.last_signaller = NULL;
+}
 void ^?{} ( global_data_t * this ) {}
+void ^?{} ( global_data_t & this ) {}
 global_data_t globalA, globalB;
 …
 //------------------------------------------------------------------------------
 void wait_op( global_data_t * mutex a, global_data_t * mutex b, unsigned i ) {
+void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
         wait( &cond, (uintptr_t)this_thread );
         yield( ((unsigned)rand48()) % 10 );
         if(a->last_thread != a->last_signaller || b->last_thread != b->last_signaller ) {
                 sout | "ERROR Barging detected, expected" | a->last_signaller | b->last_signaller | "got" | a->last_thread | b->last_thread | endl;
+        if(a.last_thread != a.last_signaller || b.last_thread != b.last_signaller ) {
+                sout | "ERROR Barging detected, expected" | a.last_signaller | b.last_signaller | "got" | a.last_thread | b.last_thread | endl;
                 abort();
+        }
         a->last_thread = b->last_thread = this_thread;
+        a.last_thread = b.last_thread = this_thread;
         yield( ((unsigned)rand48()) % 10 );
 …
 thread Waiter {};
 void main( Waiter* this ) {
+void main( Waiter & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait_op( &globalA, &globalB, i );
+                wait_op( globalA, globalB, i );
+        }
+}
 //------------------------------------------------------------------------------
 void signal_op( global_data_t * mutex a, global_data_t * mutex b ) {
+void signal_op( global_data_t & mutex a, global_data_t & mutex b ) {
         yield( ((unsigned)rand48()) % 10 );
         a->last_thread = b->last_thread = a->last_signaller = b->last_signaller = this_thread;
+        [a.last_thread, b.last_thread, a.last_signaller, b.last_signaller] = this_thread;
         if( !is_empty( &cond ) ) {
 …
                 yield( ((unsigned)rand48()) % 10 );
                 if(a->last_thread != next || b->last_thread != next) {
                         sout | "ERROR Barging detected, expected" | next | "got" | a->last_thread | b->last_thread | endl;
+                if(a.last_thread != next || b.last_thread != next) {
+                        sout | "ERROR Barging detected, expected" | next | "got" | a.last_thread | b.last_thread | endl;
                         abort();
+                }
 …
 thread Signaller {};
 void main( Signaller* this ) {
+void main( Signaller & this ) {
         while( !done ) {
                 signal_op( &globalA, &globalB );
+                signal_op( globalA, globalB );
+        }
+}
 //------------------------------------------------------------------------------
 void barge_op( global_data_t * mutex a ) {
         a->last_thread = this_thread;
+void barge_op( global_data_t & mutex a ) {
+        a.last_thread = this_thread;
+}
 thread Barger {};
 void main( Barger* this ) {
+void main( Barger & this ) {
         for( unsigned i = 0; !done; i++ ) {
                 //Choose some monitor to barge into with some irregular pattern
                 bool choose_a = (i % 13) > (i % 17);
+                barge_op( choose_a ? &globalA : &globalB );
+                if ( choose_a ) barge_op( globalA );
+                else barge_op( globalB );
+        }
+}

src/tests/sched-int-disjoint.c

-              raf08051
+              r28e58fd
 monitor global_data_t;
 void ?{}( global_data_t * this );
 void ^?{} ( global_data_t * this );
+void ?{}( global_data_t & this );
+void ^?{} ( global_data_t & this );
 monitor global_data_t {
 …
 volatile bool all_done;
 void ?{}( global_data_t * this ) {
         this->counter == 0;
         this->state = BARGE;
+void ?{}( global_data_t & this ) {
+        this.counter == 0;
+        this.state = BARGE;
+}
 void ^?{} ( global_data_t * this ) {}
+void ^?{} ( global_data_t & this ) {}
 //------------------------------------------------------------------------------
 // Barging logic
 void barge( global_data_t * mutex d ) {
         d->state = BARGE;
+void barge( global_data_t & mutex d ) {
+        d.state = BARGE;
+}
 thread Barger {};
 void main( Barger * this ) {
+void main( Barger & this ) {
         while( !all_done ) {
                 barge( &data );
+                barge( data );
                 yield();
+        }
 …
 //------------------------------------------------------------------------------
 // Waiting logic
 bool wait( global_t * mutex m, global_data_t * mutex d ) {
+bool wait( global_t & mutex m, global_data_t & mutex d ) {
         wait( &cond );
         if( d->state != SIGNAL ) {
+        if( d.state != SIGNAL ) {
                 sout | "ERROR barging!" | endl;
+        }
         d->counter++;
+        d.counter++;
         if( (d->counter % 1000) == 0 ) sout | d->counter | endl;
+        if( (d.counter % 1000) == 0 ) sout | d.counter | endl;
         return d->counter < N;
+        return d.counter < N;
+}
 thread Waiter {};
 void main( Waiter * this ) {
         while( wait( &mut, &data ) ) { yield(); }
+void main( Waiter & this ) {
+        while( wait( mut, data ) ) { yield(); }
+}
 …
 //------------------------------------------------------------------------------
 // Signalling logic
 void signal( condition * cond, global_t * mutex a, global_data_t * mutex b ) {
         b->state = SIGNAL;
+void signal( condition * cond, global_t & mutex a, global_data_t & mutex b ) {
+        b.state = SIGNAL;
         signal( cond );
+}
 void logic( global_t * mutex a ) {
         signal( &cond, a, &data );
+void logic( global_t & mutex a ) {
+        signal( &cond, a, data );
         yield( (unsigned)rand48() % 10 );
 …
 thread Signaller {};
 void main( Signaller * this ) {
+void main( Signaller & this ) {
         while( !all_done ) {
                 logic( &mut );
+                logic( mut );
                 yield();
+        }

src/tests/sched-int-wait.c

-              raf08051
+              r28e58fd
 //----------------------------------------------------------------------------------------------------
 // Tools
 void signal( condition * cond, global_t * mutex a, global_t * mutex b ) {
+void signal( condition * cond, global_t & mutex a, global_t & mutex b ) {
         signal( cond );
+}
 void signal( condition * cond, global_t * mutex a, global_t * mutex b, global_t * mutex c ) {
+void signal( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
         signal( cond );
+}
 void wait( condition * cond, global_t * mutex a, global_t * mutex b ) {
+void wait( condition * cond, global_t & mutex a, global_t & mutex b ) {
         wait( cond );
+}
 void wait( condition * cond, global_t * mutex a, global_t * mutex b, global_t * mutex c ) {
+void wait( condition * cond, global_t & mutex a, global_t & mutex b, global_t & mutex c ) {
         wait( cond );
+}
 …
 //----------------------------------------------------------------------------------------------------
 // Signaler
 void main( Signaler* this ) {
+void main( Signaler & this ) {
         while( waiter_left != 0 ) {
 …
                 switch( action ) {
                         case 0:
                                 signal( &condABC, &globalA, &globalB, &globalC );
+                                signal( &condABC, globalA, globalB, globalC );
                                 break;
                         case 1:
                                 signal( &condAB , &globalA, &globalB );
+                                signal( &condAB , globalA, globalB );
                                 break;
                         case 2:
                                 signal( &condBC , &globalB, &globalC );
+                                signal( &condBC , globalB, globalC );
                                 break;
                         case 3:
                                 signal( &condAC , &globalA, &globalC );
+                                signal( &condAC , globalA, globalC );
                                 break;
                         default:
 …
 //----------------------------------------------------------------------------------------------------
 // Waiter ABC
 void main( WaiterABC* this ) {
+void main( WaiterABC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condABC, &globalA, &globalB, &globalC );
+                wait( &condABC, globalA, globalB, globalC );
+        }
 …
 //----------------------------------------------------------------------------------------------------
 // Waiter AB
 void main( WaiterAB* this ) {
+void main( WaiterAB & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condAB , &globalA, &globalB );
+                wait( &condAB , globalA, globalB );
+        }
 …
 //----------------------------------------------------------------------------------------------------
 // Waiter AC
 void main( WaiterAC* this ) {
+void main( WaiterAC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condAC , &globalA, &globalC );
+                wait( &condAC , globalA, globalC );
+        }
 …
 //----------------------------------------------------------------------------------------------------
 // Waiter BC
 void main( WaiterBC* this ) {
+void main( WaiterBC & this ) {
         for( int i = 0; i < N; i++ ) {
                 wait( &condBC , &globalB, &globalC );
+                wait( &condBC , globalB, globalC );
+        }

src/tests/swap.c

-              raf08051
+              r28e58fd
 // swap.c --
 //
 // Author           : Richard C. Bilson
+// Author           : Peter A. Buhr
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Apr 21 08:10:41 2016
 // Update Count     : 69
+// Last Modified On : Wed Aug 23 20:34:45 2017
+// Update Count     : 70
 //
 …
         char c1 = 'a', c2 = 'b';
         sout | "char\t\t\t" | c1 | ' ' | c2 | "\t\t\tswap ";
         swap( &c1, &c2 );
+        swap( c1, c2 );
         sout | '\t' | c1 | ' ' | c2 | endl;
         signed int i1 = -1, i2 = -2;
         sout | "signed int\t\t" | i1 | i2 | "\t\t\tswap ";
         swap( &i1, &i2 );
+        swap( i1, i2 );
         sout | '\t' | i1 | i2 | endl;
         unsigned int ui1 = 1, ui2 = 2;
         sout | "unsigned int\t\t" | ui1 | ui2 | "\t\t\tswap ";
         swap( &ui1, &ui2 );
+        swap( ui1, ui2 );
         sout | '\t' | ui1 | ui2 | endl;
         signed long int li1 = -1, li2 = -2;
         sout | "signed long int\t\t" | li1 | li2 | "\t\t\tswap ";
         swap( &li1, &li2 );
+        swap( li1, li2 );
         sout | '\t' | li1 | li2 | endl;
         unsigned long int uli1 = 1, uli2 = 2;
         sout | "unsigned long int\t" | uli1 | uli2 | "\t\t\tswap ";
         swap( &uli1, &uli2 );
+        swap( uli1, uli2 );
         sout | '\t' | uli1 | uli2 | endl;
         signed long long int lli1 = -1, lli2 = -2;
         sout | "signed long long int\t" | lli1 | lli2 | "\t\t\tswap ";
         swap( &lli1, &lli2 );
+        swap( lli1, lli2 );
         sout | '\t' | lli1 | lli2 | endl;
         unsigned long long int ulli1 = 1, ulli2 = 2;
         sout | "unsigned long long int\t" | ulli1 | ulli2 | "\t\t\tswap ";
         swap( &ulli1, &ulli2 );
+        swap( ulli1, ulli2 );
         sout | '\t' | ulli1 | ulli2 | endl;
         float f1 = 1.5, f2 = 2.5;
         sout | "float\t\t\t" | f1 | f2 | "\t\t\tswap ";
         swap( &f1, &f2 );
+        swap( f1, f2 );
         sout | '\t' | f1 | f2 | endl;
         double d1 = 1.5, d2 = 2.5;
         sout | "double\t\t\t" | d1 | d2 | "\t\t\tswap ";
         swap( &d1, &d2 );
+        swap( d1, d2 );
         sout | '\t' | d1 | d2 | endl;
         long double ld1 = 1.5, ld2 = 2.5;
         sout | "long double\t\t" | ld1 | ld2 | "\t\t\tswap ";
         swap( &ld1, &ld2 );
+        swap( ld1, ld2 );
         sout | '\t' | ld1 | ld2 | endl;
         float _Complex fc1 = 1.5f+1.5if, fc2 = 2.5f+2.5if;
         sout | "float _Complex\t\t" | fc1 | fc2 | "\tswap ";
         swap( &fc1, &fc2 );
+        swap( fc1, fc2 );
         sout | '\t' | fc1 | fc2 | endl;
         double _Complex dc1 = 1.5d+1.5id, dc2 = 2.5d+2.5id;
         sout | "double _Complex\t\t" | dc1 | dc2 | "\tswap ";
         swap( &dc1, &dc2 );
+        swap( dc1, dc2 );
         sout | '\t' | dc1 | dc2 | endl;
         long double _Complex ldc1 = 1.5d+1.5il, ldc2 = 2.5d+2.5il;
         sout | "long double _Complex\t" | ldc1 | ldc2 | "\tswap ";
         swap( &ldc1, &ldc2 );
+        swap( ldc1, ldc2 );
         sout | '\t' | ldc1 | ldc2 | endl;
 …
         ofstream * ?|?( ofstream * os, S s ) { return os | s.i | s.j; }
         sout | "struct S\t\t" | s1 | "," | s2 | "\t\tswap ";
         swap( &s1, &s2 );
+        swap( s1, s2 );
         sout | '\t' | s1 | "," | s2 | endl;
 } // main

src/tests/test.py

-              raf08051
+              r28e58fd
 # parses the Makefile to find the machine type (32-bit / 64-bit)
 def getMachineType():
         sh('echo "void ?{}(int*a,int b){}int main(){return 0;}" > .dummy.c')
+        sh('echo "void ?{}(int&a,int b){}int main(){return 0;}" > .dummy.c')
         ret, out = sh("make .dummy -s", print2stdout=True)
 …
         if make_ret == 0 :
                 # fetch optional input
                 stdinput = "< .in/%s.txt" % test.name if isfile(".in/%s.txt" % test.path) else ""
+                stdinput = "< .in/%s.txt" % test.name if isfile(".in/%s.txt" % test.name) else ""
                 if fileIsExecutable(test.name) :

src/tests/thread.c

-              raf08051
+              r28e58fd
 thread Second { semaphore* lock; };
 void ?{}( First * this, semaphore* lock ) { this->lock = lock; }
 void ?{}( Second * this, semaphore* lock ) { this->lock = lock; }
+void ?{}( First & this, semaphore & lock ) { this.lock = &lock; }
+void ?{}( Second & this, semaphore & lock ) { this.lock = &lock; }
 void main(First* this) {
+void main(First& this) {
         for(int i = 0; i < 10; i++) {
                 sout | "First : Suspend No." | i + 1 | endl;
                 yield();
+        }
         V(this->lock);
+        V(this.lock);
+}
 void main(Second* this) {
         P(this->lock);
+void main(Second& this) {
+        P(this.lock);
         for(int i = 0; i < 10; i++) {
                 sout | "Second : Suspend No." | i + 1 | endl;
 …
                 processor p;
+                {
                         First  f = { &lock };
                         Second s = { &lock };
+                        First  f = { lock };
+                        Second s = { lock };
+                }
+        }

src/tests/tupleAssign.c

raf08051	r28e58fd
48	48	int z;
49	49	} x;
50		X ?=?(X * x, double d) {}
	50	X ?=?(X & x, double d) {}
51	51	[int, double, int] t;
52	52

src/tests/tupleMember.c

raf08051	r28e58fd
34	34	} v;
35	35
36		~~lvalue V~~ h() {
	36	V & h() {
37	37	static V local = { 111, { 222, 333 }, 444.5 };
38	38	return local;

src/tests/tupleVariadic.c

-              raf08051
+              r28e58fd
+}
 forall( dtype T, ttype Params | sized(T) | { void ?{}(T *, Params); } )
+forall( dtype T, ttype Params | sized(T) | { void ?{}(T &, Params); } )
 T * new(Params p);
 …
 // xxx - eventually this will be collapsed...x
 void ?{}(array * a) {
         a->size = 0;
         a->data = 0;
+void ?{}(array & a) {
+        a.size = 0;
+        a.data = 0;
         printf("called ?{} with no a\n");
+}
 void ?{}(array * a, int a0) {
         a->size = 1;
         a->data = (int*)malloc(sizeof(int)*a->size);
         a->data[0] = a0;
+void ?{}(array & a, int a0) {
+        a.size = 1;
+        a.data = (int*)malloc(sizeof(int)*a.size);
+        a.data[0] = a0;
         printf("called ?{} with a: %d\n", a0);
+}
 void ?{}(array * a, int a0, int a1) {
         a->size = 2;
         a->data = (int*)malloc(sizeof(int)*a->size);
         a->data[0] = a0;
         a->data[1] = a1;
+void ?{}(array & a, int a0, int a1) {
+        a.size = 2;
+        a.data = (int*)malloc(sizeof(int)*a.size);
+        a.data[0] = a0;
+        a.data[1] = a1;
         printf("called ?{} with a: %d %d\n", a0, a1);
+}
 void ?{}(array * a, int a0, int a1, int a2) {
         a->size = 3;
         a->data = (int*)malloc(sizeof(int)*a->size);
         a->data[0] = a0;
         a->data[1] = a1;
         a->data[2] = a2;
+void ?{}(array & a, int a0, int a1, int a2) {
+        a.size = 3;
+        a.data = (int*)malloc(sizeof(int)*a.size);
+        a.data[0] = a0;
+        a.data[1] = a1;
+        a.data[2] = a2;
         printf("called ?{} with a: %d %d %d\n", a0, a1, a2);
+}
 // test use of a tuple argument
 [void] ?{}(array * a, [int, int, int, int] args) {
+[void] ?{}(array & a, [int, int, int, int] args) {
         int a0, a1, a2, a3;
         [a0, a1, a2, a3] = args;
         a->size = 4;
         a->data = malloc(sizeof(int)*a->size);
         a->data[0] = a0;
         a->data[1] = a1;
         a->data[2] = a2;
         a->data[3] = a3;
+        a.size = 4;
+        a.data = malloc(sizeof(int)*a.size);
+        a.data[0] = a0;
+        a.data[1] = a1;
+        a.data[2] = a2;
+        a.data[3] = a3;
         printf("called ?{} with a: %d %d %d %d\n", a0, a1, a2, a3);
+}

src/tests/vector/array.h

raf08051	r28e58fd
21	21	// element has index 0.
22	22	trait array( otype array_type, otype elt_type ) {
23		~~lvalue elt_type~~ ?[?]( array_type, int );
	23	elt_type & ?[?]( array_type, int );
24	24	};
25	25

src/tests/vector/vector_int.c

-              raf08051
+              r28e58fd
 #define DEFAULT_CAPACITY 20
 void ?{}( vector_int * vec ) {
+void ?{}( vector_int & vec ) {
         vec { DEFAULT_CAPACITY };
+}
 void ?{}( vector_int * vec, int reserve ) {
         vec->last = -1;
         vec->capacity = reserve;
         vec->data = malloc( sizeof( int ) * reserve );
+void ?{}( vector_int & vec, int reserve ) {
+        vec.last = -1;
+        vec.capacity = reserve;
+        vec.data = malloc( sizeof( int ) * reserve );
+}
 void ?{}( vector_int * vec, vector_int other ) {
         vec->last = other.last;
         vec->capacity = other.capacity;
         vec->data = malloc( sizeof( int ) * other.capacity );
         for (int i = 0; i < vec->last; i++) {
                 vec->data[i] = other.data[i];
+void ?{}( vector_int & vec, vector_int other ) {
+        vec.last = other.last;
+        vec.capacity = other.capacity;
+        vec.data = malloc( sizeof( int ) * other.capacity );
+        for (int i = 0; i < vec.last; i++) {
+                vec.data[i] = other.data[i];
+        }
+}
 void ^?{}( vector_int * vec ) {
         free( vec->data );
+void ^?{}( vector_int & vec ) {
+        free( vec.data );
+}
 …
 // implement bounded_array
 lvalue int ?[?]( vector_int * vec, int index ) {
+int & ?[?]( vector_int * vec, int index ) {
         return vec->data[ index ];
+}

src/tests/vector/vector_int.h

-              raf08051
+              r28e58fd
 } vector_int;
 void ?{}( vector_int * );                                                               // allocate vector with default capacity
 void ?{}( vector_int *, int reserve );                                  // allocate vector with specified capacity
 void ?{}( vector_int * vec, vector_int other );                 // copy constructor
 void ^?{}( vector_int * );                                                              // deallocate vector's storage
+void ?{}( vector_int & );                                                               // allocate vector with default capacity
+void ?{}( vector_int &, int reserve );                                  // allocate vector with specified capacity
+void ?{}( vector_int & vec, vector_int other );     // copy constructor
+void ^?{}( vector_int & );                // deallocate vector's storage
 void reserve( vector_int *vec, int reserve );                   // reserve more capacity
 …
 // implement bounded_array
 lvalue int ?[?]( vector_int * vec, int index );                 // access to arbitrary element (does not resize)
 int last( vector_int * vec );                                                   // return last element
+int & ?[?]( vector_int * vec, int index );                              // access to arbitrary element (does not resize)
+int last( vector_int * vec );             // return last element
 // Local Variables: //

src/tests/vector/vector_test.c

-              raf08051
+              r28e58fd
 // Author           : Richard C. Bilson
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Rob Schluntz
 // Last Modified On : Wed Apr 27 17:31:27 2016
 // Update Count     : 18
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Aug 24 08:15:38 2017
+// Update Count     : 19
 //
 …
         sout | "enter N elements and C-d on a separate line:" | endl;
         for ( ;; ) {
                 sin | &num;
+                sin | num;
           if ( fail( sin ) || eof( sin ) ) break;
                 append( &vec, num );

Context Navigation

Changes in / [af08051:28e58fd]

Legend: