Changeset 46438e4

Timestamp:

Jun 7, 2019, 11:21:07 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

1e6ea4e1

Parents:

866545b (diff), 05d55ff (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• src/AST/AssertAcyclic.cpp (modified) (3 diffs)
• src/AST/AssertAcyclic.hpp (modified) (2 diffs)
• src/AST/Convert.cpp (modified) (11 diffs)
• src/AST/Expr.cpp (modified) (1 diff)
• src/AST/Expr.hpp (modified) (5 diffs)
• src/AST/GenericSubstitution.cpp (modified) (2 diffs)
• src/AST/GenericSubstitution.hpp (modified) (1 diff)
• src/AST/Init.hpp (modified) (2 diffs)
• src/AST/Node.hpp (modified) (4 diffs)
• src/AST/Pass.hpp (modified) (1 diff)
• src/AST/porting.md (modified) (1 diff)
• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/Common/Indenter.h (modified) (2 diffs)
• src/GenPoly/Lvalue.cc (modified) (1 diff)
• src/InitTweak/FixInit.cc (modified) (1 diff)
• src/ResolvExpr/CurrentObject.cc (modified) (5 diffs)
• src/ResolvExpr/CurrentObject.h (modified) (4 diffs)
• src/ResolvExpr/Resolver.cc (modified) (8 diffs)
• tests/.expect/KRfunctions.x64.txt (modified) (2 diffs)
• tests/.expect/attributes.x64.txt (modified) (10 diffs)
• tests/.expect/declarationSpecifier.x64.txt (modified) (28 diffs)
• tests/.expect/extension.x64.txt (modified) (3 diffs)
• tests/.expect/functions.x64.txt (modified) (3 diffs)
• tests/.expect/gccExtensions.x64.txt (modified) (1 diff)

src/AST/AssertAcyclic.cpp

@@ -10 +10 @@
 // Created On       : Thu Jun 06 15:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Jun 06 15:00:00 2019
-// Update Count     : 0
+// Last Modified On : Fri Jun 07 14:32:00 2019
+// Update Count     : 1
 //
 
@@ -20 +20 @@
 namespace {
 
-class NoStrongCyclesCore : public ast::WithGuards {
+class NoStrongCyclesCore {
     std::vector<const ast::Node *> parents;
 public:
-        void previsit ( const ast::Node * node ) {
-                for (auto & p : parents) {
-                        assert(p != node);
+        void previsit( const ast::Node * node ) {
+                for (auto & parent : parents) {
+                        assert(parent != node);
                 }
                 parents.push_back(node);
-                GuardAction( [this]() { parents.pop_back(); } );
+        }
+        void postvisit( const ast::Node * ) {
+                parents.pop_back();
         }
 };
@@ -36 +38 @@
 namespace ast {
 
-void assertAcyclic( const std::list< ast::ptr< ast::Decl > > translationUnit ) {
+void assertAcyclic( const std::list< ast::ptr< ast::Decl > > & translationUnit ) {
         Pass<NoStrongCyclesCore> visitor;
         for ( auto & decl : translationUnit ) {

src/AST/AssertAcyclic.hpp

@@ -8 +8 @@
 //
 // Author           : Andrew Beach
-// Created On       : Thr May 6 15:00:00 2019
+// Created On       : Thr Jun  6 15:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr May 6 15:00:00 2019
-// Update Count     : 0
+// Last Modified On : Fri Jun  7 14:32:00 2019
+// Update Count     : 1
 //
 
@@ -25 +25 @@
 namespace ast {
 
-void assertAcyclic( const std::list< ast::ptr< ast::Decl > > translationUnit );
+void assertAcyclic( const std::list< ast::ptr< ast::Decl > > & translationUnit );
 
 }

src/AST/Convert.cpp

@@ -16 +16 @@
 #include "Convert.hpp"
 
+#include <deque>
 #include <unordered_map>
 
@@ -575 +576 @@
 
                 if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
-                        const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
+                        const ast::InferredParams &srcParams = srcInferred.inferParams();
                         for (auto srcParam : srcParams) {
                                 tgtInferParams[srcParam.first] = ParamEntry(
@@ -585 +586 @@
                         }
                 } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
-                        const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
+                        const ast::ResnSlots &srcSlots = srcInferred.resnSlots();
                         for (auto srcSlot : srcSlots) {
                                 tgtResnSlots.push_back(srcSlot);
@@ -735 +736 @@
                 expr->var = get<DeclarationWithType>().accept1(node->var);
                 Type * type = expr->var->get_type()->clone();
+                if(FunctionType * ft = dynamic_cast<FunctionType*>(type)) {
+                        if(node->result.as<ast::PointerType>()) {
+                                type = new PointerType({}, ft);
+                        }
+                }
+
                 type->set_lvalue( true );
-                expr->set_result( type );
+                expr->result = type ;
                 this->node = expr;
                 return nullptr;
@@ -782 +789 @@
                         assert (!rslt->isType);
                 }
-                if (node->type) {
+                else {
+                        assert(node->type);
                         rslt = new SizeofExpr(
                                 get<Type>().accept1(node->type)
@@ -803 +811 @@
                         assert (!rslt->isType);
                 }
-                if (node->type) {
+                else {
+                        assert(node->type);
                         rslt = new AlignofExpr(
                                 get<Type>().accept1(node->type)
@@ -1413 +1422 @@
 #       define GET_ACCEPT_V(child, type) \
                 getAcceptV< ast::type, decltype( old->child ) >( old->child )
+        
+        template<typename NewT, typename OldC>
+        std::deque< ast::ptr<NewT> > getAcceptD( OldC& old ) {
+                std::deque< ast::ptr<NewT> > ret;
+                for ( auto a : old ) {
+                        a->accept( *this );
+                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
+                        node = nullptr;
+                }
+                return ret;
+        }
+
+#       define GET_ACCEPT_D(child, type) \
+                getAcceptD< ast::type, decltype( old->child ) >( old->child )
 
         ast::Label make_label(Label* old) {
@@ -2149 +2172 @@
                 );
 
-                visitBaseExpr( old,
+                visitBaseExpr_SkipResultType( old,
                         expr
                 );
@@ -2155 +2178 @@
                 expr->var = GET_ACCEPT_1(var, DeclWithType);
                 expr->result = expr->var->get_type();
+                if(const ast::FunctionType * ft = expr->result.as<ast::FunctionType>()) {
+                        if(dynamic_cast<PointerType *>(old->result)) {
+                                expr->result = new ast::PointerType(ft);
+                        }
+                }
                 add_qualifiers( expr->result, ast::CV::Lvalue );
                 this->node = expr;
@@ -2449 +2477 @@
 
         virtual void visit( UntypedInitExpr * old ) override final {
-                std::vector<ast::InitAlternative> initAlts;
+                std::deque<ast::InitAlternative> initAlts;
                 for (auto ia : old->initAlts) {
                         initAlts.push_back(ast::InitAlternative(
@@ -2714 +2742 @@
                 this->node = new ast::Designation(
                         old->location,
-                        GET_ACCEPT_V(designators, Expr)
+                        GET_ACCEPT_D(designators, Expr)
                 );
         }

src/AST/Expr.cpp

@@ -163 +163 @@
         result = mem->get_type();
         // substitute aggregate generic parameters into member type
-        genericSubsitution( aggregate->result ).apply( result );
+        genericSubstitution( aggregate->result ).apply( result );
         // ensure lvalue and appropriate restrictions from aggregate type
         add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );

src/AST/Expr.hpp

@@ -17 +17 @@
 
 #include <cassert>
+#include <deque>
 #include <map>
 #include <string>
@@ -111 +112 @@
                 }
 
-                const ResnSlots& resnSlotsConst() const {
+                const ResnSlots& resnSlots() const {
                         if (mode == Slots) {
                                 return data.resnSlots;
@@ -128 +129 @@
                 }
 
-                const InferredParams& inferParamsConst() const {
+                const InferredParams& inferParams() const {
                         if (mode == Params) {
                                 return data.inferParams;
@@ -134 +135 @@
                         assert(!"Mode was not already Params");
                         return *((InferredParams*)nullptr);
+                }
+
+                /// splices other InferUnion into this one. Will fail if one union is in `Slots` mode 
+                /// and the other is in `Params`.
+                void splice( InferUnion && o ) {
+                        if ( o.mode == Empty ) return;
+                        if ( mode == Empty ) { init_from( o ); return; }
+                        assert( mode == o.mode && "attempt to splice incompatible InferUnion" );
+
+                        if ( mode == Slots ){
+                                data.resnSlots.insert( 
+                                        data.resnSlots.end(), o.data.resnSlots.begin(), o.data.resnSlots.end() );
+                        } else if ( mode == Params ) {
+                                for ( const auto & p : o.data.inferParams ) {
+                                        data.inferParams[p.first] = std::move(p.second);
+                                }
+                        } else assert(!"invalid mode");
                 }
         };
@@ -695 +713 @@
 public:
         ptr<Expr> expr;
-        std::vector<InitAlternative> initAlts;
-
-        UntypedInitExpr( const CodeLocation & loc, const Expr * e, std::vector<InitAlternative> && as )
+        std::deque<InitAlternative> initAlts;
+
+        UntypedInitExpr( const CodeLocation & loc, const Expr * e, std::deque<InitAlternative> && as )
         : Expr( loc ), expr( e ), initAlts( std::move(as) ) {}
 

src/AST/GenericSubstitution.cpp

@@ -31 +31 @@
                 TypeSubstitution sub;
 
-                void previsit( const Type * ty ) {
-                        assertf( false, "Attempted generic substitution for non-aggregate type: %s",
-                                toString( ty ).c_str() );
+                void previsit( const Type * ) {
+                        // allow empty substitution for non-generic type
+                        visit_children = false;
                 }
 
@@ -40 +40 @@
                 }
 
-                void previsit( const ReferenceToType * ty ) {
+        private:
+                // make substitution for generic type
+                void makeSub( const ReferenceToType * ty ) {
                         visit_children = false;
-                        // build substitution from base parameters
                         const AggregateDecl * aggr = ty->aggr();
                         sub = TypeSubstitution{ aggr->params.begin(), aggr->params.end(), ty->params.begin() };
+                }
+
+        public:
+                void previsit( const StructInstType * ty ) {
+                        makeSub( ty );
+                }
+
+                void previsit( const UnionInstType * ty ) {
+                        makeSub( ty );
                 }
         };
 }
 
-TypeSubstitution genericSubsitution( const Type * ty ) {
+TypeSubstitution genericSubstitution( const Type * ty ) {
         Pass<GenericSubstitutionBuilder> builder;
         maybe_accept( ty, builder );

src/AST/GenericSubstitution.hpp

@@ -22 +22 @@
 class Type;
 
-TypeSubstitution genericSubsitution( const Type * );
+TypeSubstitution genericSubstitution( const Type * );
 
 }

src/AST/Init.hpp

@@ -16 +16 @@
 #pragma once
 
+#include <deque>
 #include <utility>        // for move
 #include <vector>
@@ -35 +36 @@
 class Designation final : public ParseNode {
 public:
-        std::vector<ptr<Expr>> designators;
+        std::deque<ptr<Expr>> designators;
 
-        Designation( const CodeLocation& loc, std::vector<ptr<Expr>>&& ds = {} )
+        Designation( const CodeLocation& loc, std::deque<ptr<Expr>>&& ds = {} )
         : ParseNode( loc ), designators( std::move(ds) ) {}
 

src/AST/Node.hpp

@@ -154 +154 @@
 
         template< enum Node::ref_type o_ref_t >
-        ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.node) {
+        ptr_base( const ptr_base<node_t, o_ref_t> & o ) : node(o.get()) {
                 if( node ) _inc(node);
         }
 
         template< enum Node::ref_type o_ref_t >
-        ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.node) {
+        ptr_base( ptr_base<node_t, o_ref_t> && o ) : node(o.get()) {
                 if( node ) _inc(node);
         }
@@ -184 +184 @@
         template< enum Node::ref_type o_ref_t >
         ptr_base & operator=( const ptr_base<node_t, o_ref_t> & o ) {
-                assign(o.node);
+                assign(o.get());
                 return *this;
         }
@@ -190 +190 @@
         template< enum Node::ref_type o_ref_t >
         ptr_base & operator=( ptr_base<node_t, o_ref_t> && o ) {
-                assign(o.node);
+                assign(o.get());
                 return *this;
         }
@@ -228 +228 @@
         void _check() const;
 
-protected:
         const node_t * node;
 };

src/AST/Pass.hpp

@@ -287 +287 @@
                 at_cleanup( [func](void *) { func(); }, nullptr );
         }
+
+        /// When this node is finished being visited, call a member of an object.
+        template<typename T>
+        void GuardMethod( T * obj, void (T::*method)() ) {
+                at_cleanup( [ method ]( void * object ) {
+                        static_cast< T * >( object )->method();
+                }, static_cast< void * >( obj ) );
+        }
 };
 

src/AST/porting.md

@@ -238 +238 @@
     * also now returns `const AggregateDecl *`
 * `genericSubstitution()` moved to own visitor in `AST/GenericSubstitution.hpp`
+  * subsumes old `makeGenericSubstitution()`
 
 `BasicType`

src/CodeGen/CodeGenerator.cc

@@ -116 +116 @@
         }
 
-        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), options( pretty, genC, lineMarks, printExprTypes ), endl( *this ) {}
-        CodeGenerator::CodeGenerator( std::ostream & os, const Options &options ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), options(options), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( 0, CodeGenerator::tabsize ), output( os ), printLabels( *this ), options( pretty, genC, lineMarks, printExprTypes ), endl( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, const Options &options ) : indent( 0, CodeGenerator::tabsize ), output( os ), printLabels( *this ), options(options), endl( *this ) {}
 
         string CodeGenerator::mangleName( DeclarationWithType * decl ) {

src/Common/Indenter.h

@@ -23 +23 @@
         unsigned int amt;         ///< spaces in one level of indentation
 
-        Indenter( unsigned int indent = 0, unsigned int amt = tabsize ) 
-        : indent( indent*amt ), amt( amt ) {}
-        
-        Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
-        Indenter & operator-=(int nlevels) { indent -= amt*nlevels; return *this; }
+        Indenter( unsigned int indent = 0, unsigned int amt = tabsize )
+        : indent( indent ), amt( amt ) {}
+
+        Indenter & operator+=(int nlevels) { indent += nlevels; return *this; }
+        Indenter & operator-=(int nlevels) { indent -= nlevels; return *this; }
         Indenter operator+(int nlevels) { Indenter indenter = *this; return indenter += nlevels; }
         Indenter operator-(int nlevels) { Indenter indenter = *this; return indenter -= nlevels; }
@@ -35 +35 @@
 
 inline std::ostream & operator<<( std::ostream & out, const Indenter & indent ) {
-        return out << std::string(indent.indent, ' ');
+        return out << std::string(indent.indent * indent.amt, ' ');
 }
 

src/GenPoly/Lvalue.cc

@@ -196 +196 @@
                                 unsigned int i = 0;
                                 const unsigned int end = ftype->parameters.size();
+
+                                /// The for loop may eagerly dereference the iterators and fail on empty lists
+                                if(i == end) { return appExpr; }
                                 for ( auto p : unsafe_group_iterate( appExpr->args, ftype->parameters ) ) {
                                         if (i == end) break;

src/InitTweak/FixInit.cc

@@ -301 +301 @@
                                 replacement = new CastExpr( replacement, base->clone() );
                         }
-                        size_t replaced = DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } );
-                        if(replaced == 0) {
-                                objDecl->print(std::cerr);
-                                std::cerr << "-----" << std::endl;
-                                dtor->print(std::cerr);
-                                std::cerr << "Failed to replace " << objDecl << std::endl;
-                                abort();
-                        }
+                        DeclReplacer::replace( dtor, { std::make_pair( objDecl, replacement ) } );
                         dtorFunc->statements->push_back( strict_dynamic_cast<Statement *>( dtor ) );
 

src/ResolvExpr/CurrentObject.cc

@@ -16 +16 @@
 #include <stddef.h>                    // for size_t
 #include <cassert>                     // for assertf, assert, safe_dynamic_...
+#include <deque>
 #include <iostream>                    // for ostream, operator<<, basic_ost...
 #include <stack>                       // for stack
@@ -21 +22 @@
 
 #include "AST/Expr.hpp"                // for InitAlternative
+#include "AST/GenericSubstitution.hpp" // for genericSubstitution
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
+#include "AST/Type.hpp"
 #include "Common/Indenter.h"           // for Indenter, operator<<
 #include "Common/SemanticError.h"      // for SemanticError
@@ -583 +586 @@
 
 namespace ast {
-
-        /// Iterates members of a type by initializer
-        class MemberIterator {
-        public:
-                virtual ~MemberIterator() {}
-
-                /// retrieve the list of possible (Type,Designation) pairs for the current position in the 
-                /// current object
-                virtual std::vector< InitAlternative > operator* () const = 0;
-        
-        protected:
-                /// helper for operator*; aggregates must add designator to each init alternative, but 
-                /// adding designators in operator* creates duplicates
-                virtual std::vector< InitAlternative > first() const = 0;
-        };
+        /// create a new MemberIterator that traverses a type correctly
+        MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type );
 
         /// Iterates "other" types (e.g. basic, pointer) which do not change at list initializer entry
@@ -606 +596 @@
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
 
-                std::vector< InitAlternative > operator* () const override { return first(); }
-
-        protected:
-                std::vector< InitAlternative > first() const override {
+                void setPosition( 
+                        std::deque< ptr< Expr > >::const_iterator begin, 
+                        std::deque< ptr< Expr > >::const_iterator end
+                ) override {
+                        if ( begin != end ) {
+                                SemanticError( location, "Un-designated initializer given non-empty designator" );
+                        }
+                }
+
+                std::deque< InitAlternative > operator* () const override { return first(); }
+
+                operator bool() const override { return type; }
+
+                SimpleIterator & bigStep() override { return smallStep(); }
+                SimpleIterator & smallStep() override {
+                        type = nullptr;  // empty on increment because no members
+                        return *this;
+                }
+
+                const Type * getType() override { return type; }
+
+                const Type * getNext() override { return type; }
+
+                std::deque< InitAlternative > first() const override {
                         if ( type ) return { InitAlternative{ type, new Designation{ location } } };
                         return {};
@@ -615 +625 @@
         };
 
+        /// Iterates array types
+        class ArrayIterator final : public MemberIterator {
+                CodeLocation location;
+                readonly< ArrayType > array = nullptr;
+                readonly< Type > base = nullptr;
+                size_t index = 0;
+                size_t size = 0;
+                std::unique_ptr< MemberIterator > memberIter;
+
+                void setSize( const Expr * expr ) {
+                        auto res = eval(expr);
+                        if ( ! res.second ) {
+                                SemanticError( location, 
+                                        toString("Array designator must be a constant expression: ", expr ) );
+                        }
+                        size = res.first;
+                }
+
+        public:
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) 
+                : location( loc ), array( at ), base( at->base ) {
+                        PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
+                        memberIter.reset( createMemberIterator( loc, base ) );
+                        if ( at->isVarLen ) {
+                                SemanticError( location, at, "VLA initialization does not support @=: " );
+                        }
+                        setSize( at->dimension );
+                }
+
+                void setPosition( const Expr * expr ) {
+                        // need to permit integer-constant-expressions, including: integer constants, 
+                        // enumeration constants, character constants, sizeof expressions, alignof expressions, 
+                        // cast expressions
+                        if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
+                                try {
+                                        index = constExpr->intValue();
+                                } catch ( SemanticErrorException & ) {
+                                        SemanticError( expr, 
+                                                "Constant expression of non-integral type in array designator: " );
+                                }
+                        } else if ( auto castExpr = dynamic_cast< const CastExpr * >( expr ) ) {
+                                setPosition( castExpr->arg );
+                        } else if ( 
+                                dynamic_cast< const SizeofExpr * >( expr ) 
+                                || dynamic_cast< const AlignofExpr * >( expr ) 
+                        ) {
+                                index = 0;
+                        } else {
+                                assertf( false, 
+                                        "bad designator given to ArrayIterator: %s", toString( expr ).c_str() );
+                        }
+                }
+
+                void setPosition( 
+                        std::deque< ptr< Expr > >::const_iterator begin, 
+                        std::deque< ptr< Expr > >::const_iterator end
+                ) override {
+                        if ( begin == end ) return;
+
+                        setPosition( *begin );
+                        memberIter->setPosition( ++begin, end );
+                }
+
+                std::deque< InitAlternative > operator* () const override { return first(); }
+
+                operator bool() const override { return index < size; }
+
+                ArrayIterator & bigStep() override {
+                        PRINT( std::cerr << "bigStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
+                        ++index;
+                        memberIter.reset( index < size ? createMemberIterator( location, base ) : nullptr );
+                        return *this;
+                }
+
+                ArrayIterator & smallStep() override {
+                        PRINT( std::cerr << "smallStep in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
+                        if ( memberIter ) {
+                                PRINT( std::cerr << "has member iter: " << *memberIter << std::endl; )
+                                memberIter->smallStep();
+                                if ( *memberIter ) {
+                                        PRINT( std::cerr << "has valid member iter" << std::endl; )
+                                        return *this;
+                                }
+                        }
+                        return bigStep();
+                }
+
+                const Type * getType() override { return array; }
+
+                const Type * getNext() override { return base; }
+
+                std::deque< InitAlternative > first() const override {
+                        PRINT( std::cerr << "first in ArrayIterator (" << index << "/" << size << ")" << std::endl; )
+                        if ( memberIter && *memberIter ) {
+                                std::deque< InitAlternative > ret = memberIter->first();
+                                for ( InitAlternative & alt : ret ) {
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
+                                                ConstantExpr::from_ulong( location, index ) );
+                                }
+                                return ret;
+                        }
+                        return {};
+                }
+        };
+
+        class AggregateIterator : public MemberIterator {
+        protected:
+                using MemberList = std::vector< ptr< Decl > >;
+
+                CodeLocation location;
+                std::string kind;  // for debug
+                std::string name;
+                const Type * inst;
+                const MemberList & members;
+                MemberList::const_iterator curMember;
+                bool atbegin = true;  // false at first {small,big}Step
+                const Type * curType = nullptr;
+                std::unique_ptr< MemberIterator > memberIter = nullptr;
+                TypeSubstitution sub;
+
+                bool init() {
+                        PRINT( std::cerr << "--init()--" << members.size() << std::endl; )
+                        if ( curMember != members.end() ) {
+                                if ( auto field = curMember->as< ObjectDecl >() ) {
+                                        PRINT( std::cerr << "incremented to field: " << field << std::endl; )
+                                        curType = field->get_type();
+                                        memberIter.reset( createMemberIterator( location, curType ) );
+                                        return true;
+                                }
+                        }
+                        return false;
+                }
+
+                AggregateIterator( 
+                        const CodeLocation & loc, const std::string k, const std::string & n, const Type * i, 
+                        const MemberList & ms )
+                : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ), 
+                  sub( genericSubstitution( i ) ) {
+                        PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
+                        init();
+                }
+
+        public:
+                void setPosition( 
+                        std::deque< ptr< Expr > >::const_iterator begin, 
+                        std::deque< ptr< Expr > >::const_iterator end
+                ) final {
+                        if ( begin == end ) return;
+
+                        if ( auto varExpr = begin->as< VariableExpr >() ) {
+                                for ( curMember = members.begin(); curMember != members.end(); ++curMember ) {
+                                        if ( *curMember != varExpr->var ) continue;
+
+                                        ++begin;
+
+                                        memberIter.reset( createMemberIterator( location, varExpr->result ) );
+                                        curType = varExpr->result;
+                                        atbegin = curMember == members.begin() && begin == end;
+                                        memberIter->setPosition( begin, end );
+                                        return;
+                                }
+                                assertf( false, 
+                                        "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
+                        } else {
+                                assertf( false, 
+                                        "bad designator given to %s: %s", kind.c_str(), toString( *begin ).c_str() );
+                        }
+                }
+
+                std::deque< InitAlternative > operator* () const final {
+                        if ( memberIter && *memberIter ) {
+                                std::deque< InitAlternative > ret = memberIter->first();
+                                PRINT( std::cerr << "sub: " << sub << std::endl; )
+                                for ( InitAlternative & alt : ret ) {
+                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
+                                                new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
+                                        // need to substitute for generic types so that casts are to concrete types
+                                        PRINT( std::cerr << "  type is: " << alt.type; )
+                                        sub.apply( alt.type ); // also apply to designation??
+                                        PRINT( std::cerr << " ==> " << alt.type << std::endl; )
+                                }
+                                return ret;
+                        }
+                        return {};
+                }
+
+                AggregateIterator & smallStep() final {
+                        PRINT( std::cerr << "smallStep in " << kind << std::endl; )
+                        atbegin = false;
+                        if ( memberIter ) {
+                                PRINT( std::cerr << "has member iter, incrementing..." << std::endl; )
+                                memberIter->smallStep();
+                                if ( *memberIter ) {
+                                        PRINT( std::cerr << "success!" << std::endl; )
+                                        return *this;
+                                }
+                        }
+                        return bigStep();
+                }
+
+                AggregateIterator & bigStep() override = 0;
+
+                const Type * getType() final { return inst; }
+
+                const Type * getNext() final {
+                        return ( memberIter && *memberIter ) ? memberIter->getType() : nullptr;
+                }
+
+                std::deque< InitAlternative > first() const final {
+                        std::deque< InitAlternative > ret;
+                        PRINT( std::cerr << "first " << kind << std::endl; )
+                        if ( memberIter && *memberIter ) {
+                                PRINT( std::cerr << "adding children" << std::endl; )
+                                ret = memberIter->first();
+                                for ( InitAlternative & alt : ret ) {
+                                        PRINT( std::cerr << "iterating and adding designators" << std::endl; )
+                                        alt.designation.get_and_mutate()->designators.emplace_front( 
+                                                new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
+                                }
+                        }
+                        if ( atbegin ) {
+                                // only add self if at the very beginning of the structure
+                                PRINT( std::cerr << "adding self" << std::endl; )
+                                ret.emplace_front( inst, new Designation{ location } );
+                        }
+                        return ret;
+                }
+        };
+
+        class StructIterator final : public AggregateIterator {
+        public:
+                StructIterator( const CodeLocation & loc, const StructInstType * inst )
+                : AggregateIterator( loc, "StructIterator", inst->name, inst, inst->base->members ) {}
+
+                operator bool() const override {
+                        return curMember != members.end() || (memberIter && *memberIter);
+                }
+
+                StructIterator & bigStep() override {
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        while ( curMember != members.end() ) {
+                                ++curMember;
+                                if ( init() ) return *this;
+                        }
+                        return *this;
+                }
+        };
+
+        class UnionIterator final : public AggregateIterator {
+        public:
+                UnionIterator( const CodeLocation & loc, const UnionInstType * inst )
+                : AggregateIterator( loc, "UnionIterator", inst->name, inst, inst->base->members ) {}
+
+                operator bool() const override { return memberIter && *memberIter; }
+
+                UnionIterator & bigStep() override {
+                        // unions only initialize one member
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        curMember = members.end();
+                        return *this;
+                }
+        };
+
+        class TupleIterator final : public AggregateIterator {
+        public:
+                TupleIterator( const CodeLocation & loc, const TupleType * inst ) 
+                : AggregateIterator( 
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members 
+                ) {}
+
+                operator bool() const override {
+                        return curMember != members.end() || (memberIter && *memberIter);
+                }
+
+                TupleIterator & bigStep() override {
+                        PRINT( std::cerr << "bigStep in " << kind << std::endl; )
+                        atbegin = false;
+                        memberIter = nullptr;
+                        curType = nullptr;
+                        while ( curMember != members.end() ) {
+                                ++curMember;
+                                if ( init() ) return *this;
+                        }
+                        return *this;
+                }
+        };
+
+        MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
+                if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
+                        if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
+                                return new StructIterator{ loc, sit };
+                        } else if ( auto uit = dynamic_cast< const UnionInstType * >( aggr ) ) {
+                                return new UnionIterator{ loc, uit };
+                        } else {
+                                assertf( 
+                                        dynamic_cast< const EnumInstType * >( aggr ) 
+                                                || dynamic_cast< const TypeInstType * >( aggr ), 
+                                        "Encountered unhandled ReferenceToType in createMemberIterator: %s",
+                                                toString( type ).c_str() );
+                                return new SimpleIterator{ loc, type };
+                        }
+                } else if ( auto at = dynamic_cast< const ArrayType * >( type ) ) {
+                        return new ArrayIterator{ loc, at };
+                } else if ( auto tt = dynamic_cast< const TupleType * >( type ) ) {
+                        return new TupleIterator{ loc, tt };
+                } else {
+                        return new SimpleIterator{ loc, type };
+                }
+        }
+
         CurrentObject::CurrentObject( const CodeLocation & loc, const Type * type ) : objStack() {
                 objStack.emplace_back( new SimpleIterator{ loc, type } );
         }
 
-        std::vector< InitAlternative > CurrentObject::getOptions() {
+        void CurrentObject::setNext( const ast::Designation * designation ) {
+                PRINT( std::cerr << "____setNext" << designation << std::endl; )
+                assertf( ! objStack.empty(), "obj stack empty in setNext" );
+                objStack.back()->setPosition( designation->designators );
+        }
+
+        void CurrentObject::increment() {
+                PRINT( std::cerr << "____increment" << std::endl; )
+                if ( objStack.empty() ) return;
+                PRINT( std::cerr << *objStack.back() << std::endl; )
+                objStack.back()->smallStep();
+        }
+
+        void CurrentObject::enterListInit( const CodeLocation & loc ) {
+                PRINT( std::cerr << "____entering list init" << std::endl; )
+                assertf( ! objStack.empty(), "empty obj stack entering list init" );
+                const ast::Type * type = objStack.back()->getNext();
+                assert( type );
+                objStack.emplace_back( createMemberIterator( loc, type ) );
+        }
+
+        void CurrentObject::exitListInit() {
+                PRINT( std::cerr << "____exiting list init" << std::endl; )
+                assertf( ! objStack.empty(), "objstack empty" );
+                objStack.pop_back();
+                if ( ! objStack.empty() ) {
+                        PRINT( std::cerr << *objStack.back() << std::endl; )
+                        objStack.back()->bigStep();
+                }
+        }
+
+        std::deque< InitAlternative > CurrentObject::getOptions() {
                 PRINT( std::cerr << "____getting current options" << std::endl; )
                 assertf( ! objStack.empty(), "objstack empty in getOptions" );
                 return **objStack.back();
+        }
+
+        const Type * CurrentObject::getCurrentType() {
+                PRINT( std::cerr << "____getting current type" << std::endl; )
+                assertf( ! objStack.empty(), "objstack empty in getCurrentType" );
+                return objStack.back()->getNext();
         }
 }

src/ResolvExpr/CurrentObject.h

@@ -16 +16 @@
 #pragma once
 
+#include <deque>
 #include <list>   // for list
 #include <memory> // for unique_ptr
@@ -21 +22 @@
 #include <vector>
 
+#include "AST/Node.hpp"  // for ptr
 #include "Common/CodeLocation.h"
 
@@ -59 +61 @@
         // AST class types
         class Designation;
-        class InitAlternative;
+        struct InitAlternative;
         class Type;
 
-        // forward declaration of internal detail
-        class MemberIterator;
+        /// Iterates members of a type by initializer
+        class MemberIterator {
+        public:
+                virtual ~MemberIterator() {}
+
+                /// Internal set position based on iterator ranges
+                virtual void setPosition( 
+                        std::deque< ptr< Expr > >::const_iterator it, 
+                        std::deque< ptr< Expr > >::const_iterator end ) = 0;
+
+                /// walks the current object using the given designators as a guide
+                void setPosition( const std::deque< ptr< Expr > > & designators ) {
+                        setPosition( designators.begin(), designators.end() );
+                }
+
+                /// retrieve the list of possible (Type,Designation) pairs for the current position in the 
+                /// current object
+                virtual std::deque< InitAlternative > operator* () const = 0;
+
+                /// true if the iterator is not currently at the end
+                virtual operator bool() const = 0;
+
+                /// moves the iterator by one member in the current object
+                virtual MemberIterator & bigStep() = 0;
+
+                /// moves the iterator by one member in the current subobject
+                virtual MemberIterator & smallStep() = 0;
+
+                /// the type of the current object
+                virtual const Type * getType() = 0;
+
+                /// the type of the current subobject
+                virtual const Type * getNext() = 0;
+        
+                /// helper for operator*; aggregates must add designator to each init alternative, but 
+                /// adding designators in operator* creates duplicates
+                virtual std::deque< InitAlternative > first() const = 0;
+        };
 
         /// Builds initializer lists in resolution
@@ -73 +111 @@
                 CurrentObject( const CodeLocation & loc, const Type * type );
 
+                /// sets current position using the resolved designation
+                void setNext( const ast::Designation * designation );
+                /// steps to next sub-object of current object
+                void increment();
+                /// sets new current object for the duration of this brace-enclosed intializer-list
+                void enterListInit( const CodeLocation & loc );
+                /// restores previous current object
+                void exitListInit();
                 /// produces a list of alternatives (Type *, Designation *) for the current sub-object's 
                 /// initializer.
-                std::vector< InitAlternative > getOptions();
+                std::deque< InitAlternative > getOptions();
+                /// produces the type of the current object but no subobjects
+                const Type * getCurrentType();
         };
 } // namespace ast

src/ResolvExpr/Resolver.cc

@@ -781 +781 @@
         }
 
-        template< typename T >
-        bool isCharType( T t ) {
+        bool isCharType( Type * t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
                         return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
@@ -1071 +1070 @@
                 };
 
+                /// Swaps argument into expression pointer, saving original environment
+                void swap_and_save_env( ast::ptr< ast::Expr > & expr, const ast::Expr * newExpr ) {
+                        ast::ptr< ast::TypeSubstitution > env = expr->env;
+                        expr.set_and_mutate( newExpr )->env = env;
+                }
+
                 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
                 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
@@ -1076 +1081 @@
                                 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
                                         // cast is to the same type as its argument, remove it
-                                        ast::ptr< ast::TypeSubstitution > env = castExpr->env;
-                                        expr.set_and_mutate( castExpr->arg )->env = env;
+                                        swap_and_save_env( expr, castExpr->arg );
                                 }
                         }
@@ -1175 +1179 @@
                         return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
                 }
+
+                /// check if a type is a character type
+                bool isCharType( const ast::Type * t ) {
+                        if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
+                                return bt->kind == ast::BasicType::Char 
+                                        || bt->kind == ast::BasicType::SignedChar 
+                                        || bt->kind == ast::BasicType::UnsignedChar;
+                        }
+                        return false;
+                }
         }
 
@@ -1213 +1227 @@
                 void previsit( const ast::WaitForStmt * );
 
-                void previsit( const ast::SingleInit * );
-                void previsit( const ast::ListInit * );
+                const ast::SingleInit * previsit( const ast::SingleInit * );
+                const ast::ListInit * previsit( const ast::ListInit * );
                 void previsit( const ast::ConstructorInit * );
         };
@@ -1363 +1377 @@
         const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
                 if ( caseStmt->cond ) {
-                        std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
+                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
                                 "expression." );
@@ -1374 +1388 @@
                         // whether it would perform a conversion.
                         if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
-                                ast::ptr< ast::TypeSubstitution > env = castExpr->env;
-                                newExpr.set_and_mutate( castExpr->arg )->env = env;
+                                swap_and_save_env( newExpr, castExpr->arg );
                         }
                         
@@ -1438 +1451 @@
         }
 
-        void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)singleInit;
-                assert(false);
-        }
-
-        void Resolver_new::previsit( const ast::ListInit * listInit ) {
-                #warning unimplemented; Resolver port in progress
-                (void)listInit;
-                assert(false);
+
+
+        const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
+                visit_children = false;
+                // resolve initialization using the possibilities as determined by the `currentObject` 
+                // cursor.
+                ast::Expr * untyped = new ast::UntypedInitExpr{ 
+                        singleInit->location, singleInit->value, currentObject.getOptions() };
+                ast::ptr<ast::Expr> newExpr = findKindExpression( untyped, symtab );
+                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
+
+                // move cursor to the object that is actually initialized
+                currentObject.setNext( initExpr->designation );
+
+                // discard InitExpr wrapper and retain relevant pieces.
+                // `initExpr` may have inferred params in the case where the expression specialized a 
+                // function pointer, and newExpr may already have inferParams of its own, so a simple 
+                // swap is not sufficient
+                ast::Expr::InferUnion inferred = initExpr->inferred;
+                swap_and_save_env( newExpr, initExpr->expr );
+                newExpr.get_and_mutate()->inferred.splice( std::move(inferred) );
+
+                // get the actual object's type (may not exactly match what comes back from the resolver 
+                // due to conversions)
+                const ast::Type * initContext = currentObject.getCurrentType();
+
+                removeExtraneousCast( newExpr, symtab );
+
+                // check if actual object's type is char[]
+                if ( auto at = dynamic_cast< const ast::ArrayType * >( initContext ) ) {
+                        if ( isCharType( at->base ) ) {
+                                // check if the resolved type is char*
+                                if ( auto pt = newExpr->result.as< ast::PointerType >() ) {
+                                        if ( isCharType( pt->base ) ) {
+                                                // strip cast if we're initializing a char[] with a char* 
+                                                // e.g. char x[] = "hello"
+                                                if ( auto ce = newExpr.as< ast::CastExpr >() ) {
+                                                        swap_and_save_env( newExpr, ce->arg );
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                // move cursor to next object in preparation for next initializer
+                currentObject.increment();
+
+                // set initializer expression to resolved expression
+                return ast::mutate_field( singleInit, &ast::SingleInit::value, std::move(newExpr) );
+        }
+
+        const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) {
+                // move cursor into brace-enclosed initializer-list
+                currentObject.enterListInit( listInit->location );
+
+                assert( listInit->designations.size() == listInit->initializers.size() );
+                for ( unsigned i = 0; i < listInit->designations.size(); ++i ) {
+                        // iterate designations and initializers in pairs, moving the cursor to the current 
+                        // designated object and resolving the initializer against that object
+                        #warning unimplemented; Resolver port in progress
+                        assert(false);
+                }
+
+                visit_children = false;
+                return listInit;
         }
 

tests/.expect/KRfunctions.x64.txt

@@ -1 +1 @@
 signed int _X2f0Fi_iPKii__1(signed int _X1ai_1, const signed int *_X1bPKi_1, signed int _X1ci_1){
-          __attribute__ ((unused)) signed int _X10_retval_f0i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f0i_1;
+}
 signed int _X2f1Fi_PiiPi__1(signed int *_X1aPi_1, __attribute__ ((unused)) signed int _X1bi_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int _X10_retval_f1i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f1i_1;
+}
 signed int _X2f2Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int _X10_retval_f2i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f2i_1;
+}
 struct S {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
@@ -17 +17 @@
 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
-          }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
+    }
 
-        }
+}
 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
-          }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
+    }
 
-        }
+}
 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
-          }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
+    }
 
-        }
+}
 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
-          struct S _X4_retS1S_1;
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
-          }
+    struct S _X4_retS1S_1;
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
+    }
 
-          {
-            ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
-          }
+    {
+        ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
+    }
 
-          return _X4_retS1S_1;
-        }
+    return _X4_retS1S_1;
+}
 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
 
-        }
+}
 signed int _X2f3Fi_S1SS1SPi__1(struct S _X1aS1S_1, struct S _X1bS1S_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int _X10_retval_f3i_1;
-          struct S _X1sS1S_2;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f3i_1;
+    struct S _X1sS1S_2;
+}
 signed int _X2f4Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int _X10_retval_f4i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f4i_1;
+}
 signed int _X2f5Fi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int _X10_retval_f5i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f5i_1;
+}
 signed int (*_X2f6FFi_i__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(__attribute__ ((unused)) signed int __anonymous_object0){
-          __attribute__ ((unused)) signed int (*_X10_retval_f6Fi_i__1)(signed int __anonymous_object1);
-        }
+    __attribute__ ((unused)) signed int (*_X10_retval_f6Fi_i__1)(signed int __anonymous_object1);
+}
 signed int (*_X2f7FFi_ii__iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))(signed int _X1ai_1, signed int _X1bi_1){
-          __attribute__ ((unused)) signed int (*_X10_retval_f7Fi_ii__1)(signed int _X1ai_1, signed int _X1bi_1);
-        }
+    __attribute__ ((unused)) signed int (*_X10_retval_f7Fi_ii__1)(signed int _X1ai_1, signed int _X1bi_1);
+}
 signed int *_X2f8FPi_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int *_X10_retval_f8Pi_1;
-        }
+    __attribute__ ((unused)) signed int *_X10_retval_f8Pi_1;
+}
 signed int *const _X2f9FPi_PiiPi__1(signed int *_X1aPi_1, signed int _X1bi_1, signed int *_X1cPi_1){
-          __attribute__ ((unused)) signed int *const _X10_retval_f9KPi_1;
-        }
+    __attribute__ ((unused)) signed int *const _X10_retval_f9KPi_1;
+}
 signed int *(*_X3f10FFPi_ii__iPiPid__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1, double _X1yd_1))(signed int _X1xi_1, signed int _X1yi_1){
-          __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
-          signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
-          {
-            ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
-          }
+    __attribute__ ((unused)) signed int *(*_X11_retval_f10FPi_ii__1)(signed int _X1xi_1, signed int _X1yi_1);
+    signed int *_X1xFPi_ii__2(signed int __anonymous_object2, signed int __anonymous_object3);
+    {
+        ((void)(_X11_retval_f10FPi_ii__1=_X1xFPi_ii__2) /* ?{} */);
+    }
 
-          return _X11_retval_f10FPi_ii__1;
-        }
+    return _X11_retval_f10FPi_ii__1;
+}
 signed int (*_X3f11FPA0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f11PA0i_1)[];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f11PA0i_1)[];
+}
 signed int (*_X3f12FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )10)];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )10)];
+}
 signed int (*_X3f13FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned long int )10)];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f13PA0A0i_1)[][((unsigned long int )10)];
+}
 signed int (*_X3f14FPA0A0i_iPiPi__1(signed int _X1ai_1, signed int *_X1bPi_1, signed int *_X1cPi_1))[][((unsigned long int )10)]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned long int )10)];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f14PA0A0i_1)[][((unsigned long int )10)];
+}
 signed int _X3f15Fi_iii__1(signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
-          __attribute__ ((unused)) signed int _X11_retval_f15i_1;
-        }
+    __attribute__ ((unused)) signed int _X11_retval_f15i_1;
+}
 const signed int _X4fredFi___1(){
-          __attribute__ ((unused)) const signed int _X12_retval_fredKi_1;
-          signed int *(*_X1xFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
-          signed int _X1ai_2;
-          signed int _X1bi_2;
-          {
-            signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
-            ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
-          }
+    __attribute__ ((unused)) const signed int _X12_retval_fredKi_1;
+    signed int *(*_X1xFPi_ii__2)(signed int __anonymous_object4, signed int __anonymous_object5);
+    signed int _X1ai_2;
+    signed int _X1bi_2;
+    {
+        signed int *(*_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
+        ((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4)));
+    }
 
-          const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
-            __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;
-          }
-          const signed int _X2f2Fi_iii__2(signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
-            __attribute__ ((unused)) const signed int _X10_retval_f2Ki_2;
-          }
-        }
+    const signed int _X2f1Fi_iPiPi__2(signed int _X1ai_2, signed int *_X1bPi_2, signed int *_X1cPi_2){
+        __attribute__ ((unused)) const signed int _X10_retval_f1Ki_2;
+    }
+    const signed int _X2f2Fi_iii__2(signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
+        __attribute__ ((unused)) const signed int _X10_retval_f2Ki_2;
+    }
+}

tests/.expect/attributes.x64.txt

@@ -1 +1 @@
 signed int _X2laFi___1(){
-          __attribute__ ((unused)) signed int _X10_retval_lai_1;
-          {
-            L: __attribute__ ((unused)) ((void)1);
-          }
-
-        }
+    __attribute__ ((unused)) signed int _X10_retval_lai_1;
+    {
+        L: __attribute__ ((unused)) ((void)1);
+    }
+
+}
 struct __attribute__ ((unused)) __anonymous0 {
-        };
+};
 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
@@ -13 +13 @@
 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
-        }
+}
 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
-        }
+}
 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
-        }
+}
 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
-          struct __anonymous0 _X4_retS12__anonymous0_1;
-          {
-            ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
-          }
-
-          return _X4_retS12__anonymous0_1;
-        }
+    struct __anonymous0 _X4_retS12__anonymous0_1;
+    {
+        ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
+    }
+
+    return _X4_retS12__anonymous0_1;
+}
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
-        };
+};
 static inline void _X12_constructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1);
 static inline void _X12_constructorFv_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1);
@@ -34 +34 @@
 static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1);
 static inline void _X12_constructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1){
-        }
+}
 static inline void _X12_constructorFv_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
-        }
+}
 static inline void _X11_destructorFv_S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1){
-        }
+}
 static inline struct Agn2 _X16_operator_assignFS4Agn2_S4Agn2S4Agn2_autogen___1(struct Agn2 *_X4_dstS4Agn2_1, struct Agn2 _X4_srcS4Agn2_1){
-          struct Agn2 _X4_retS4Agn2_1;
-          {
-            ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
-          }
-
-          return _X4_retS4Agn2_1;
-        }
+    struct Agn2 _X4_retS4Agn2_1;
+    {
+        ((void)_X12_constructorFv_S4Agn2S4Agn2_autogen___1((&_X4_retS4Agn2_1), (*_X4_dstS4Agn2_1)));
+    }
+
+    return _X4_retS4Agn2_1;
+}
 enum __attribute__ ((unused)) __anonymous1 {
-          _X2E1KM12__anonymous1_1,
-        };
+    _X2E1KM12__anonymous1_1,
+};
 enum __attribute__ ((unused)) Agn3;
 enum __attribute__ ((packed)) Agn3 {
-          _X2E2KM4Agn3_1,
-        };
+    _X2E2KM4Agn3_1,
+};
 struct __attribute__ ((unused)) __anonymous2 {
-        };
+};
 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
@@ -61 +61 @@
 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
-        }
+}
 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
-        }
+}
 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
-        }
+}
 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
-          struct __anonymous2 _X4_retS12__anonymous2_1;
-          {
-            ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
-          }
-
-          return _X4_retS12__anonymous2_1;
-        }
+    struct __anonymous2 _X4_retS12__anonymous2_1;
+    {
+        ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
+    }
+
+    return _X4_retS12__anonymous2_1;
+}
 struct __attribute__ ((unused)) Agn4 {
-        };
+};
 static inline void _X12_constructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1);
 static inline void _X12_constructorFv_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1);
@@ -81 +81 @@
 static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1);
 static inline void _X12_constructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1){
-        }
+}
 static inline void _X12_constructorFv_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
-        }
+}
 static inline void _X11_destructorFv_S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1){
-        }
+}
 static inline struct Agn4 _X16_operator_assignFS4Agn4_S4Agn4S4Agn4_autogen___1(struct Agn4 *_X4_dstS4Agn4_1, struct Agn4 _X4_srcS4Agn4_1){
-          struct Agn4 _X4_retS4Agn4_1;
-          {
-            ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
-          }
-
-          return _X4_retS4Agn4_1;
-        }
+    struct Agn4 _X4_retS4Agn4_1;
+    {
+        ((void)_X12_constructorFv_S4Agn4S4Agn4_autogen___1((&_X4_retS4Agn4_1), (*_X4_dstS4Agn4_1)));
+    }
+
+    return _X4_retS4Agn4_1;
+}
 struct Fdl {
-          __attribute__ ((unused)) signed int _X2f1i_1;
-          __attribute__ ((unused)) signed int _X2f2i_1;
-          __attribute__ ((unused,unused)) signed int _X2f3i_1;
-          __attribute__ ((unused)) signed int _X2f4i_1;
-          __attribute__ ((unused,unused)) signed int _X2f5i_1;
-          __attribute__ ((used,packed)) signed int _X2f6i_1;
-          __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
-          __attribute__ ((used,used,unused)) signed int _X2f8i_1;
-          __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
-        };
+    __attribute__ ((unused)) signed int _X2f1i_1;
+    __attribute__ ((unused)) signed int _X2f2i_1;
+    __attribute__ ((unused,unused)) signed int _X2f3i_1;
+    __attribute__ ((unused)) signed int _X2f4i_1;
+    __attribute__ ((unused,unused)) signed int _X2f5i_1;
+    __attribute__ ((used,packed)) signed int _X2f6i_1;
+    __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
+    __attribute__ ((used,used,unused)) signed int _X2f8i_1;
+    __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
+};
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1);
@@ -119 +119 @@
 static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1) /* ^?{} */);
+    }
+
+}
 static inline struct Fdl _X16_operator_assignFS3Fdl_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
-          struct Fdl _X4_retS3Fdl_1;
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
-          }
-
-          return _X4_retS3Fdl_1;
-        }
+    struct Fdl _X4_retS3Fdl_1;
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X4_srcS3Fdl_1._X2f1i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X4_srcS3Fdl_1._X2f2i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X4_srcS3Fdl_1._X2f3i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X4_srcS3Fdl_1._X2f4i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X4_srcS3Fdl_1._X2f5i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X4_srcS3Fdl_1._X2f6i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X4_srcS3Fdl_1._X2f7i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X4_srcS3Fdl_1._X2f8i_1));
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X4_srcS3Fdl_1._X2f9Pi_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
+    }
+
+    return _X4_retS3Fdl_1;
+}
 static inline void _X12_constructorFv_S3Fdli_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+
+}
 __attribute__ ((unused)) signed int _X1fFi___1() asm ( "xyz" );
 __attribute__ ((used,used)) const signed int _X3vd1Ki_1;
@@ -629 +629 @@
 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
 __attribute__ ((unused)) signed int _X2f1Fi___1(){
-          __attribute__ ((unused)) signed int _X10_retval_f1i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f1i_1;
+}
 __attribute__ ((unused,unused,unused,used)) signed int **const _X2f2FPPi___1();
 __attribute__ ((unused,unused,unused)) signed int **const _X2f2FPPi___1(){
-          __attribute__ ((unused)) signed int **const _X10_retval_f2KPPi_1;
-        }
+    __attribute__ ((unused)) signed int **const _X10_retval_f2KPPi_1;
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
 __attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
-          __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
-        }
+    __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
 __attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object2){
-          __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
-        }
+    __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
+}
 signed int _X3vtrFi___1(){
-          __attribute__ ((unused)) signed int _X11_retval_vtri_1;
-          __attribute__ ((unused,unused,used)) signed int _X2t1i_2;
-          __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t2PPi_2;
-          __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
-          __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
-          __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
-          __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
-        }
+    __attribute__ ((unused)) signed int _X11_retval_vtri_1;
+    __attribute__ ((unused,unused,used)) signed int _X2t1i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t2PPi_2;
+    __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
+    __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
+}
 signed int _X4ipd1Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int _X1pi_1, __attribute__ ((unused,unused,unused)) signed int _X1qi_1);
 signed int _X4ipd1Fi_ii__1(__attribute__ ((unused,unused,unused)) signed int _X1pi_1, __attribute__ ((unused,unused,unused)) signed int _X1qi_1){
-          __attribute__ ((unused)) signed int _X12_retval_ipd1i_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_ipd1i_1;
+}
 signed int _X4ipd2Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1);
 signed int _X4ipd2Fi_PiPi__1(__attribute__ ((unused,unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1){
-          __attribute__ ((unused)) signed int _X12_retval_ipd2i_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_ipd2i_1;
+}
 signed int _X4ipd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1);
 signed int _X4ipd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *_X1pPi_1, __attribute__ ((unused,unused,unused)) signed int *_X1qPi_1){
-          __attribute__ ((unused)) signed int _X12_retval_ipd3i_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_ipd3i_1;
+}
 signed int _X4ipd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X1pFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*_X1qFi___1)());
 signed int _X4ipd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X1pFi___1)(), __attribute__ ((unused,unused,unused)) signed int (*_X1qFi___1)()){
-          __attribute__ ((unused)) signed int _X12_retval_ipd4i_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_ipd4i_1;
+}
 signed int _X4tpr1Fi_i__1(__attribute__ ((unused,unused,unused)) signed int _X3Fooi_1);
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
@@ -676 +676 @@
 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
 signed int _X2adFi___1(){
-          __attribute__ ((unused)) signed int _X10_retval_adi_1;
-          __attribute__ ((used,unused)) signed int _X3ad1i_2;
-          __attribute__ ((unused,unused,unused)) signed int *_X3ad2Pi_2;
-          __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned long int )5)];
-          __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned long int )10)];
-          __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
-          __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
-          {
-            ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
-          }
-
-          {
-            ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
-          }
-
-          {
-            ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [((unsigned long int )5)]));
-          }
-
-          {
-            ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[((unsigned long int )10)]));
-          }
-
-          {
-            ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
-          }
-
-          struct __attribute__ ((unused)) __anonymous3 {
-            signed int _X1ii_2;
-          };
-          inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
-            {
-              ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
-            {
-              ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
-            {
-              ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
-            }
-
-          }
-          inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
-            struct __anonymous3 _X4_retS12__anonymous3_2;
-            {
-              ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
-            }
-
-            {
-              ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
-            }
-
-            return _X4_retS12__anonymous3_2;
-          }
-          inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
-            {
-              ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
-            }
-
-          }
-          {
-            ((void)sizeof(struct __anonymous3 ));
-          }
-
-          enum __attribute__ ((unused)) __anonymous4 {
-            _X1RKM12__anonymous4_2,
-          };
-          inline void _X12_constructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
-          }
-          inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
-            {
-              ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
-          }
-          inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
-            enum __anonymous4 _X4_retM12__anonymous4_2;
-            {
-              ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
-            }
-
-            {
-              ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
-            }
-
-            return _X4_retM12__anonymous4_2;
-          }
-          {
-            ((void)sizeof(enum __anonymous4 ));
-          }
-
+    __attribute__ ((unused)) signed int _X10_retval_adi_1;
+    __attribute__ ((used,unused)) signed int _X3ad1i_2;
+    __attribute__ ((unused,unused,unused)) signed int *_X3ad2Pi_2;
+    __attribute__ ((unused,unused,unused)) signed int _X3ad3A0i_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int (*_X3ad4PA0i_2)[((unsigned long int )10)];
+    __attribute__ ((unused,unused,unused,unused,used)) signed int _X3ad5i_2;
+    __attribute__ ((unused,unused,unused,unused,unused)) signed int _X3ad6Fi___2();
+    {
+        ((void)sizeof(__attribute__ ((unused,unused)) signed int ));
+    }
+
+    {
+        ((void)sizeof(__attribute__ ((unused,unused,unused,unused)) signed int **));
+    }
+
+    {
+        ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int [((unsigned long int )5)]));
+    }
+
+    {
+        ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int (*)[((unsigned long int )10)]));
+    }
+
+    {
+        ((void)sizeof(__attribute__ ((unused,unused,unused)) signed int ()));
+    }
+
+    struct __attribute__ ((unused)) __anonymous3 {
+        signed int _X1ii_2;
+    };
+    inline void _X12_constructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
+        {
+            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ?{} */);
         }
+
+    }
+    inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
+        {
+            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2){
+        {
+            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2) /* ^?{} */);
+        }
+
+    }
+    inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, struct __anonymous3 _X4_srcS12__anonymous3_2){
+        struct __anonymous3 _X4_retS12__anonymous3_2;
+        {
+            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X4_srcS12__anonymous3_2._X1ii_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___2((&_X4_retS12__anonymous3_2), (*_X4_dstS12__anonymous3_2)));
+        }
+
+        return _X4_retS12__anonymous3_2;
+    }
+    inline void _X12_constructorFv_S12__anonymous3i_autogen___2(struct __anonymous3 *_X4_dstS12__anonymous3_2, signed int _X1ii_2){
+        {
+            ((void)((*_X4_dstS12__anonymous3_2)._X1ii_2=_X1ii_2) /* ?{} */);
+        }
+
+    }
+    {
+        ((void)sizeof(struct __anonymous3 ));
+    }
+
+    enum __attribute__ ((unused)) __anonymous4 {
+        _X1RKM12__anonymous4_2,
+    };
+    inline void _X12_constructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
+    }
+    inline void _X12_constructorFv_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
+        {
+            ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_M12__anonymous4_intrinsic___2(__attribute__ ((unused)) enum __anonymous4 *_X4_dstM12__anonymous4_2){
+    }
+    inline enum __anonymous4 _X16_operator_assignFM12__anonymous4_M12__anonymous4M12__anonymous4_intrinsic___2(enum __anonymous4 *_X4_dstM12__anonymous4_2, enum __anonymous4 _X4_srcM12__anonymous4_2){
+        enum __anonymous4 _X4_retM12__anonymous4_2;
+        {
+            ((void)((*_X4_dstM12__anonymous4_2)=_X4_srcM12__anonymous4_2));
+        }
+
+        {
+            ((void)(_X4_retM12__anonymous4_2=(*_X4_dstM12__anonymous4_2)) /* ?{} */);
+        }
+
+        return _X4_retM12__anonymous4_2;
+    }
+    {
+        ((void)sizeof(enum __anonymous4 ));
+    }
+
+}
 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
@@ -784 +784 @@
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
 struct Vad {
-          __attribute__ ((unused)) signed int __anonymous_object27:4;
-          __attribute__ ((unused)) signed int __anonymous_object28:4;
-          __attribute__ ((unused,unused)) signed int __anonymous_object29:6;
-        };
+    __attribute__ ((unused)) signed int __anonymous_object27:4;
+    __attribute__ ((unused)) signed int __anonymous_object28:4;
+    __attribute__ ((unused,unused)) signed int __anonymous_object29:6;
+};
 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1);
 static inline void _X12_constructorFv_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1);
@@ -793 +793 @@
 static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1);
 static inline void _X12_constructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1){
-        }
+}
 static inline void _X12_constructorFv_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
-        }
+}
 static inline void _X11_destructorFv_S3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1){
-        }
+}
 static inline struct Vad _X16_operator_assignFS3Vad_S3VadS3Vad_autogen___1(struct Vad *_X4_dstS3Vad_1, struct Vad _X4_srcS3Vad_1){
-          struct Vad _X4_retS3Vad_1;
-          {
-            ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
-          }
-
-          return _X4_retS3Vad_1;
-        }
+    struct Vad _X4_retS3Vad_1;
+    {
+        ((void)_X12_constructorFv_S3VadS3Vad_autogen___1((&_X4_retS3Vad_1), (*_X4_dstS3Vad_1)));
+    }
+
+    return _X4_retS3Vad_1;
+}

tests/.expect/declarationSpecifier.x64.txt

@@ -8 +8 @@
 static volatile const signed short int _X2x8KVs_1;
 struct __anonymous0 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1);
@@ -16 +16 @@
 static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
-          {
-            ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
-          {
-            ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1){
-          {
-            ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous0 _X16_operator_assignFS12__anonymous0_S12__anonymous0S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, struct __anonymous0 _X4_srcS12__anonymous0_1){
-          struct __anonymous0 _X4_retS12__anonymous0_1;
-          {
-            ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
-          }
-
-          return _X4_retS12__anonymous0_1;
-        }
+    struct __anonymous0 _X4_retS12__anonymous0_1;
+    {
+        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X4_srcS12__anonymous0_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous0S12__anonymous0_autogen___1((&_X4_retS12__anonymous0_1), (*_X4_dstS12__anonymous0_1)));
+    }
+
+    return _X4_retS12__anonymous0_1;
+}
 static inline void _X12_constructorFv_S12__anonymous0i_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous0_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 volatile const struct __anonymous0 _X3x10KVS12__anonymous0_1;
 struct __anonymous1 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1);
 static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1);
@@ -61 +61 @@
 static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
-          {
-            ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
-          {
-            ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1){
-          {
-            ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous1 _X16_operator_assignFS12__anonymous1_S12__anonymous1S12__anonymous1_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, struct __anonymous1 _X4_srcS12__anonymous1_1){
-          struct __anonymous1 _X4_retS12__anonymous1_1;
-          {
-            ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
-          }
-
-          return _X4_retS12__anonymous1_1;
-        }
+    struct __anonymous1 _X4_retS12__anonymous1_1;
+    {
+        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X4_srcS12__anonymous1_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous1S12__anonymous1_autogen___1((&_X4_retS12__anonymous1_1), (*_X4_dstS12__anonymous1_1)));
+    }
+
+    return _X4_retS12__anonymous1_1;
+}
 static inline void _X12_constructorFv_S12__anonymous1i_autogen___1(struct __anonymous1 *_X4_dstS12__anonymous1_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous1_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 volatile const struct __anonymous1 _X3x11KVS12__anonymous1_1;
 struct __anonymous2 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1);
 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1);
@@ -106 +106 @@
 static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
-          {
-            ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
-          {
-            ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1){
-          {
-            ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous2 _X16_operator_assignFS12__anonymous2_S12__anonymous2S12__anonymous2_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, struct __anonymous2 _X4_srcS12__anonymous2_1){
-          struct __anonymous2 _X4_retS12__anonymous2_1;
-          {
-            ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
-          }
-
-          return _X4_retS12__anonymous2_1;
-        }
+    struct __anonymous2 _X4_retS12__anonymous2_1;
+    {
+        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X4_srcS12__anonymous2_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous2S12__anonymous2_autogen___1((&_X4_retS12__anonymous2_1), (*_X4_dstS12__anonymous2_1)));
+    }
+
+    return _X4_retS12__anonymous2_1;
+}
 static inline void _X12_constructorFv_S12__anonymous2i_autogen___1(struct __anonymous2 *_X4_dstS12__anonymous2_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous2_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 volatile const struct __anonymous2 _X3x12KVS12__anonymous2_1;
 struct __anonymous3 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1);
 static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1);
@@ -151 +151 @@
 static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
-          {
-            ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
-          {
-            ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1){
-          {
-            ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous3 _X16_operator_assignFS12__anonymous3_S12__anonymous3S12__anonymous3_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, struct __anonymous3 _X4_srcS12__anonymous3_1){
-          struct __anonymous3 _X4_retS12__anonymous3_1;
-          {
-            ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
-          }
-
-          return _X4_retS12__anonymous3_1;
-        }
+    struct __anonymous3 _X4_retS12__anonymous3_1;
+    {
+        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X4_srcS12__anonymous3_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous3S12__anonymous3_autogen___1((&_X4_retS12__anonymous3_1), (*_X4_dstS12__anonymous3_1)));
+    }
+
+    return _X4_retS12__anonymous3_1;
+}
 static inline void _X12_constructorFv_S12__anonymous3i_autogen___1(struct __anonymous3 *_X4_dstS12__anonymous3_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous3_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous3 _X3x13KVS12__anonymous3_1;
 struct __anonymous4 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1);
 static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1);
@@ -196 +196 @@
 static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
-          {
-            ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
-          {
-            ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1){
-          {
-            ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous4 _X16_operator_assignFS12__anonymous4_S12__anonymous4S12__anonymous4_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, struct __anonymous4 _X4_srcS12__anonymous4_1){
-          struct __anonymous4 _X4_retS12__anonymous4_1;
-          {
-            ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
-          }
-
-          return _X4_retS12__anonymous4_1;
-        }
+    struct __anonymous4 _X4_retS12__anonymous4_1;
+    {
+        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X4_srcS12__anonymous4_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous4S12__anonymous4_autogen___1((&_X4_retS12__anonymous4_1), (*_X4_dstS12__anonymous4_1)));
+    }
+
+    return _X4_retS12__anonymous4_1;
+}
 static inline void _X12_constructorFv_S12__anonymous4i_autogen___1(struct __anonymous4 *_X4_dstS12__anonymous4_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous4_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous4 _X3x14KVS12__anonymous4_1;
 struct __anonymous5 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1);
 static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1);
@@ -241 +241 @@
 static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
-          {
-            ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
-          {
-            ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1){
-          {
-            ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous5 _X16_operator_assignFS12__anonymous5_S12__anonymous5S12__anonymous5_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, struct __anonymous5 _X4_srcS12__anonymous5_1){
-          struct __anonymous5 _X4_retS12__anonymous5_1;
-          {
-            ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
-          }
-
-          return _X4_retS12__anonymous5_1;
-        }
+    struct __anonymous5 _X4_retS12__anonymous5_1;
+    {
+        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X4_srcS12__anonymous5_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous5S12__anonymous5_autogen___1((&_X4_retS12__anonymous5_1), (*_X4_dstS12__anonymous5_1)));
+    }
+
+    return _X4_retS12__anonymous5_1;
+}
 static inline void _X12_constructorFv_S12__anonymous5i_autogen___1(struct __anonymous5 *_X4_dstS12__anonymous5_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous5_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous5 _X3x15KVS12__anonymous5_1;
 struct __anonymous6 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1);
 static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1);
@@ -286 +286 @@
 static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
-          {
-            ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
-          {
-            ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1){
-          {
-            ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous6 _X16_operator_assignFS12__anonymous6_S12__anonymous6S12__anonymous6_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, struct __anonymous6 _X4_srcS12__anonymous6_1){
-          struct __anonymous6 _X4_retS12__anonymous6_1;
-          {
-            ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
-          }
-
-          return _X4_retS12__anonymous6_1;
-        }
+    struct __anonymous6 _X4_retS12__anonymous6_1;
+    {
+        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X4_srcS12__anonymous6_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous6S12__anonymous6_autogen___1((&_X4_retS12__anonymous6_1), (*_X4_dstS12__anonymous6_1)));
+    }
+
+    return _X4_retS12__anonymous6_1;
+}
 static inline void _X12_constructorFv_S12__anonymous6i_autogen___1(struct __anonymous6 *_X4_dstS12__anonymous6_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous6_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous6 _X3x16KVS12__anonymous6_1;
 struct __anonymous7 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1);
 static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1);
@@ -331 +331 @@
 static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
-          {
-            ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-          {
-            ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1){
-          {
-            ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous7 _X16_operator_assignFS12__anonymous7_S12__anonymous7S12__anonymous7_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, struct __anonymous7 _X4_srcS12__anonymous7_1){
-          struct __anonymous7 _X4_retS12__anonymous7_1;
-          {
-            ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
-          }
-
-          return _X4_retS12__anonymous7_1;
-        }
+    struct __anonymous7 _X4_retS12__anonymous7_1;
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X4_srcS12__anonymous7_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous7S12__anonymous7_autogen___1((&_X4_retS12__anonymous7_1), (*_X4_dstS12__anonymous7_1)));
+    }
+
+    return _X4_retS12__anonymous7_1;
+}
 static inline void _X12_constructorFv_S12__anonymous7i_autogen___1(struct __anonymous7 *_X4_dstS12__anonymous7_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous7_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous7 _X3x17KVS12__anonymous7_1;
 volatile const signed short int _X3x20KVs_1;
@@ -376 +376 @@
 static volatile const signed short int _X3x27KVs_1;
 struct __anonymous8 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1);
 static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1);
@@ -384 +384 @@
 static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
-          {
-            ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
-          {
-            ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1){
-          {
-            ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous8 _X16_operator_assignFS12__anonymous8_S12__anonymous8S12__anonymous8_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, struct __anonymous8 _X4_srcS12__anonymous8_1){
-          struct __anonymous8 _X4_retS12__anonymous8_1;
-          {
-            ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
-          }
-
-          return _X4_retS12__anonymous8_1;
-        }
+    struct __anonymous8 _X4_retS12__anonymous8_1;
+    {
+        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X4_srcS12__anonymous8_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous8S12__anonymous8_autogen___1((&_X4_retS12__anonymous8_1), (*_X4_dstS12__anonymous8_1)));
+    }
+
+    return _X4_retS12__anonymous8_1;
+}
 static inline void _X12_constructorFv_S12__anonymous8s_autogen___1(struct __anonymous8 *_X4_dstS12__anonymous8_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous8_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 volatile const struct __anonymous8 _X3x29KVS12__anonymous8_1;
 struct __anonymous9 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1);
 static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1);
@@ -429 +429 @@
 static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
-          {
-            ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
-          {
-            ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1){
-          {
-            ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous9 _X16_operator_assignFS12__anonymous9_S12__anonymous9S12__anonymous9_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, struct __anonymous9 _X4_srcS12__anonymous9_1){
-          struct __anonymous9 _X4_retS12__anonymous9_1;
-          {
-            ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
-          }
-
-          return _X4_retS12__anonymous9_1;
-        }
+    struct __anonymous9 _X4_retS12__anonymous9_1;
+    {
+        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X4_srcS12__anonymous9_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S12__anonymous9S12__anonymous9_autogen___1((&_X4_retS12__anonymous9_1), (*_X4_dstS12__anonymous9_1)));
+    }
+
+    return _X4_retS12__anonymous9_1;
+}
 static inline void _X12_constructorFv_S12__anonymous9s_autogen___1(struct __anonymous9 *_X4_dstS12__anonymous9_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS12__anonymous9_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 volatile const struct __anonymous9 _X3x30KVS12__anonymous9_1;
 struct __anonymous10 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1);
 static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1);
@@ -474 +474 @@
 static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
-          {
-            ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
-          {
-            ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1){
-          {
-            ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous10 _X16_operator_assignFS13__anonymous10_S13__anonymous10S13__anonymous10_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, struct __anonymous10 _X4_srcS13__anonymous10_1){
-          struct __anonymous10 _X4_retS13__anonymous10_1;
-          {
-            ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
-          }
-
-          return _X4_retS13__anonymous10_1;
-        }
+    struct __anonymous10 _X4_retS13__anonymous10_1;
+    {
+        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X4_srcS13__anonymous10_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous10S13__anonymous10_autogen___1((&_X4_retS13__anonymous10_1), (*_X4_dstS13__anonymous10_1)));
+    }
+
+    return _X4_retS13__anonymous10_1;
+}
 static inline void _X12_constructorFv_S13__anonymous10s_autogen___1(struct __anonymous10 *_X4_dstS13__anonymous10_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous10_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 volatile const struct __anonymous10 _X3x31KVS13__anonymous10_1;
 struct __anonymous11 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1);
 static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1);
@@ -519 +519 @@
 static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
-          {
-            ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
-          {
-            ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1){
-          {
-            ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous11 _X16_operator_assignFS13__anonymous11_S13__anonymous11S13__anonymous11_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, struct __anonymous11 _X4_srcS13__anonymous11_1){
-          struct __anonymous11 _X4_retS13__anonymous11_1;
-          {
-            ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
-          }
-
-          return _X4_retS13__anonymous11_1;
-        }
+    struct __anonymous11 _X4_retS13__anonymous11_1;
+    {
+        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X4_srcS13__anonymous11_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous11S13__anonymous11_autogen___1((&_X4_retS13__anonymous11_1), (*_X4_dstS13__anonymous11_1)));
+    }
+
+    return _X4_retS13__anonymous11_1;
+}
 static inline void _X12_constructorFv_S13__anonymous11s_autogen___1(struct __anonymous11 *_X4_dstS13__anonymous11_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous11_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous11 _X3x32KVS13__anonymous11_1;
 struct __anonymous12 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1);
 static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1);
@@ -564 +564 @@
 static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
-          {
-            ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
-          {
-            ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1){
-          {
-            ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous12 _X16_operator_assignFS13__anonymous12_S13__anonymous12S13__anonymous12_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, struct __anonymous12 _X4_srcS13__anonymous12_1){
-          struct __anonymous12 _X4_retS13__anonymous12_1;
-          {
-            ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
-          }
-
-          return _X4_retS13__anonymous12_1;
-        }
+    struct __anonymous12 _X4_retS13__anonymous12_1;
+    {
+        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X4_srcS13__anonymous12_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous12S13__anonymous12_autogen___1((&_X4_retS13__anonymous12_1), (*_X4_dstS13__anonymous12_1)));
+    }
+
+    return _X4_retS13__anonymous12_1;
+}
 static inline void _X12_constructorFv_S13__anonymous12s_autogen___1(struct __anonymous12 *_X4_dstS13__anonymous12_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous12_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous12 _X3x33KVS13__anonymous12_1;
 struct __anonymous13 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1);
 static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1);
@@ -609 +609 @@
 static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
-          {
-            ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
-          {
-            ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1){
-          {
-            ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous13 _X16_operator_assignFS13__anonymous13_S13__anonymous13S13__anonymous13_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, struct __anonymous13 _X4_srcS13__anonymous13_1){
-          struct __anonymous13 _X4_retS13__anonymous13_1;
-          {
-            ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
-          }
-
-          return _X4_retS13__anonymous13_1;
-        }
+    struct __anonymous13 _X4_retS13__anonymous13_1;
+    {
+        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X4_srcS13__anonymous13_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous13S13__anonymous13_autogen___1((&_X4_retS13__anonymous13_1), (*_X4_dstS13__anonymous13_1)));
+    }
+
+    return _X4_retS13__anonymous13_1;
+}
 static inline void _X12_constructorFv_S13__anonymous13s_autogen___1(struct __anonymous13 *_X4_dstS13__anonymous13_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous13_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous13 _X3x34KVS13__anonymous13_1;
 struct __anonymous14 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1);
 static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1);
@@ -654 +654 @@
 static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
-          {
-            ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
-          {
-            ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1){
-          {
-            ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous14 _X16_operator_assignFS13__anonymous14_S13__anonymous14S13__anonymous14_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, struct __anonymous14 _X4_srcS13__anonymous14_1){
-          struct __anonymous14 _X4_retS13__anonymous14_1;
-          {
-            ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
-          }
-
-          return _X4_retS13__anonymous14_1;
-        }
+    struct __anonymous14 _X4_retS13__anonymous14_1;
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X4_srcS13__anonymous14_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous14S13__anonymous14_autogen___1((&_X4_retS13__anonymous14_1), (*_X4_dstS13__anonymous14_1)));
+    }
+
+    return _X4_retS13__anonymous14_1;
+}
 static inline void _X12_constructorFv_S13__anonymous14s_autogen___1(struct __anonymous14 *_X4_dstS13__anonymous14_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous14_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous14 _X3x35KVS13__anonymous14_1;
 struct __anonymous15 {
-          signed short int _X1is_1;
-        };
+    signed short int _X1is_1;
+};
 static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1);
 static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1);
@@ -699 +699 @@
 static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1);
 static inline void _X12_constructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
-          {
-            ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
-          {
-            ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1){
-          {
-            ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous15 _X16_operator_assignFS13__anonymous15_S13__anonymous15S13__anonymous15_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, struct __anonymous15 _X4_srcS13__anonymous15_1){
-          struct __anonymous15 _X4_retS13__anonymous15_1;
-          {
-            ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
-          }
-
-          return _X4_retS13__anonymous15_1;
-        }
+    struct __anonymous15 _X4_retS13__anonymous15_1;
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X4_srcS13__anonymous15_1._X1is_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous15S13__anonymous15_autogen___1((&_X4_retS13__anonymous15_1), (*_X4_dstS13__anonymous15_1)));
+    }
+
+    return _X4_retS13__anonymous15_1;
+}
 static inline void _X12_constructorFv_S13__anonymous15s_autogen___1(struct __anonymous15 *_X4_dstS13__anonymous15_1, signed short int _X1is_1){
-          {
-            ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous15_1)._X1is_1=_X1is_1) /* ?{} */);
+    }
+
+}
 static volatile const struct __anonymous15 _X3x36KVS13__anonymous15_1;
 static inline volatile const signed int _X3f11Fi___1();
@@ -752 +752 @@
 static inline volatile const signed short int _X3f28Fs___1();
 struct __anonymous16 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1);
 static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1);
@@ -760 +760 @@
 static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
-          {
-            ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
-          {
-            ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1){
-          {
-            ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous16 _X16_operator_assignFS13__anonymous16_S13__anonymous16S13__anonymous16_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, struct __anonymous16 _X4_srcS13__anonymous16_1){
-          struct __anonymous16 _X4_retS13__anonymous16_1;
-          {
-            ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
-          }
-
-          return _X4_retS13__anonymous16_1;
-        }
+    struct __anonymous16 _X4_retS13__anonymous16_1;
+    {
+        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X4_srcS13__anonymous16_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous16S13__anonymous16_autogen___1((&_X4_retS13__anonymous16_1), (*_X4_dstS13__anonymous16_1)));
+    }
+
+    return _X4_retS13__anonymous16_1;
+}
 static inline void _X12_constructorFv_S13__anonymous16i_autogen___1(struct __anonymous16 *_X4_dstS13__anonymous16_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous16_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous16 _X3f31FS13__anonymous16___1();
 struct __anonymous17 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1);
 static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1);
@@ -805 +805 @@
 static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
-          {
-            ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
-          {
-            ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1){
-          {
-            ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous17 _X16_operator_assignFS13__anonymous17_S13__anonymous17S13__anonymous17_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, struct __anonymous17 _X4_srcS13__anonymous17_1){
-          struct __anonymous17 _X4_retS13__anonymous17_1;
-          {
-            ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
-          }
-
-          return _X4_retS13__anonymous17_1;
-        }
+    struct __anonymous17 _X4_retS13__anonymous17_1;
+    {
+        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X4_srcS13__anonymous17_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous17S13__anonymous17_autogen___1((&_X4_retS13__anonymous17_1), (*_X4_dstS13__anonymous17_1)));
+    }
+
+    return _X4_retS13__anonymous17_1;
+}
 static inline void _X12_constructorFv_S13__anonymous17i_autogen___1(struct __anonymous17 *_X4_dstS13__anonymous17_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous17_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous17 _X3f32FS13__anonymous17___1();
 struct __anonymous18 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1);
 static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1);
@@ -850 +850 @@
 static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
-          {
-            ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
-          {
-            ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1){
-          {
-            ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous18 _X16_operator_assignFS13__anonymous18_S13__anonymous18S13__anonymous18_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, struct __anonymous18 _X4_srcS13__anonymous18_1){
-          struct __anonymous18 _X4_retS13__anonymous18_1;
-          {
-            ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
-          }
-
-          return _X4_retS13__anonymous18_1;
-        }
+    struct __anonymous18 _X4_retS13__anonymous18_1;
+    {
+        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X4_srcS13__anonymous18_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous18S13__anonymous18_autogen___1((&_X4_retS13__anonymous18_1), (*_X4_dstS13__anonymous18_1)));
+    }
+
+    return _X4_retS13__anonymous18_1;
+}
 static inline void _X12_constructorFv_S13__anonymous18i_autogen___1(struct __anonymous18 *_X4_dstS13__anonymous18_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous18_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous18 _X3f33FS13__anonymous18___1();
 struct __anonymous19 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1);
 static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1);
@@ -895 +895 @@
 static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
-          {
-            ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
-          {
-            ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1){
-          {
-            ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous19 _X16_operator_assignFS13__anonymous19_S13__anonymous19S13__anonymous19_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, struct __anonymous19 _X4_srcS13__anonymous19_1){
-          struct __anonymous19 _X4_retS13__anonymous19_1;
-          {
-            ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
-          }
-
-          return _X4_retS13__anonymous19_1;
-        }
+    struct __anonymous19 _X4_retS13__anonymous19_1;
+    {
+        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X4_srcS13__anonymous19_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous19S13__anonymous19_autogen___1((&_X4_retS13__anonymous19_1), (*_X4_dstS13__anonymous19_1)));
+    }
+
+    return _X4_retS13__anonymous19_1;
+}
 static inline void _X12_constructorFv_S13__anonymous19i_autogen___1(struct __anonymous19 *_X4_dstS13__anonymous19_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous19_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous19 _X3f34FS13__anonymous19___1();
 struct __anonymous20 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1);
 static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1);
@@ -940 +940 @@
 static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
-          {
-            ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
-          {
-            ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1){
-          {
-            ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous20 _X16_operator_assignFS13__anonymous20_S13__anonymous20S13__anonymous20_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, struct __anonymous20 _X4_srcS13__anonymous20_1){
-          struct __anonymous20 _X4_retS13__anonymous20_1;
-          {
-            ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
-          }
-
-          return _X4_retS13__anonymous20_1;
-        }
+    struct __anonymous20 _X4_retS13__anonymous20_1;
+    {
+        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X4_srcS13__anonymous20_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous20S13__anonymous20_autogen___1((&_X4_retS13__anonymous20_1), (*_X4_dstS13__anonymous20_1)));
+    }
+
+    return _X4_retS13__anonymous20_1;
+}
 static inline void _X12_constructorFv_S13__anonymous20i_autogen___1(struct __anonymous20 *_X4_dstS13__anonymous20_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous20_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous20 _X3f35FS13__anonymous20___1();
 struct __anonymous21 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1);
 static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1);
@@ -985 +985 @@
 static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
-          {
-            ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
-          {
-            ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1){
-          {
-            ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous21 _X16_operator_assignFS13__anonymous21_S13__anonymous21S13__anonymous21_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, struct __anonymous21 _X4_srcS13__anonymous21_1){
-          struct __anonymous21 _X4_retS13__anonymous21_1;
-          {
-            ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
-          }
-
-          return _X4_retS13__anonymous21_1;
-        }
+    struct __anonymous21 _X4_retS13__anonymous21_1;
+    {
+        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X4_srcS13__anonymous21_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous21S13__anonymous21_autogen___1((&_X4_retS13__anonymous21_1), (*_X4_dstS13__anonymous21_1)));
+    }
+
+    return _X4_retS13__anonymous21_1;
+}
 static inline void _X12_constructorFv_S13__anonymous21i_autogen___1(struct __anonymous21 *_X4_dstS13__anonymous21_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous21_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous21 _X3f36FS13__anonymous21___1();
 struct __anonymous22 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1);
 static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1);
@@ -1030 +1030 @@
 static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
-          {
-            ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
-          {
-            ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1){
-          {
-            ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous22 _X16_operator_assignFS13__anonymous22_S13__anonymous22S13__anonymous22_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, struct __anonymous22 _X4_srcS13__anonymous22_1){
-          struct __anonymous22 _X4_retS13__anonymous22_1;
-          {
-            ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
-          }
-
-          return _X4_retS13__anonymous22_1;
-        }
+    struct __anonymous22 _X4_retS13__anonymous22_1;
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X4_srcS13__anonymous22_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous22S13__anonymous22_autogen___1((&_X4_retS13__anonymous22_1), (*_X4_dstS13__anonymous22_1)));
+    }
+
+    return _X4_retS13__anonymous22_1;
+}
 static inline void _X12_constructorFv_S13__anonymous22i_autogen___1(struct __anonymous22 *_X4_dstS13__anonymous22_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous22_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous22 _X3f37FS13__anonymous22___1();
 struct __anonymous23 {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1);
 static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1);
@@ -1075 +1075 @@
 static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
-          {
-            ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
-          {
-            ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1){
-          {
-            ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct __anonymous23 _X16_operator_assignFS13__anonymous23_S13__anonymous23S13__anonymous23_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, struct __anonymous23 _X4_srcS13__anonymous23_1){
-          struct __anonymous23 _X4_retS13__anonymous23_1;
-          {
-            ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
-          }
-
-          return _X4_retS13__anonymous23_1;
-        }
+    struct __anonymous23 _X4_retS13__anonymous23_1;
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X4_srcS13__anonymous23_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S13__anonymous23S13__anonymous23_autogen___1((&_X4_retS13__anonymous23_1), (*_X4_dstS13__anonymous23_1)));
+    }
+
+    return _X4_retS13__anonymous23_1;
+}
 static inline void _X12_constructorFv_S13__anonymous23i_autogen___1(struct __anonymous23 *_X4_dstS13__anonymous23_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS13__anonymous23_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 static inline volatile const struct __anonymous23 _X3f38FS13__anonymous23___1();
 static inline volatile const signed short int _X3f41Fs___1();
@@ -1120 +1120 @@
 static inline volatile const signed short int _X3f48Fs___1();
 signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
-          __attribute__ ((unused)) signed int _X12_retval_maini_1;
-          {
-            ((void)(_X12_retval_maini_1=0) /* ?{} */);
-          }
-
-          return _X12_retval_maini_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_maini_1;
+    {
+        ((void)(_X12_retval_maini_1=0) /* ?{} */);
+    }
+
+    return _X12_retval_maini_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return _X4mainFi_iPPKc__1((signed int )argc, (const char **)argv); }
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
-          __attribute__ ((unused)) signed int _X12_retval_maini_1;
-          {
-            signed int _tmp_cp_ret4;
-            ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
-          }
-
-          return _X12_retval_maini_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_maini_1;
+    {
+        signed int _tmp_cp_ret4;
+        ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
+    }
+
+    return _X12_retval_maini_1;
+}

tests/.expect/extension.x64.txt

@@ -3 +3 @@
 __extension__ signed int _X1ci_1;
 __extension__ struct S {
-          __extension__ signed int _X1ai_1;
-          __extension__ signed int _X1bi_1;
-          __extension__ signed int _X1ci_1;
-        };
+    __extension__ signed int _X1ai_1;
+    __extension__ signed int _X1bi_1;
+    __extension__ signed int _X1ci_1;
+};
 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
@@ -15 +15 @@
 static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1);
 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1) /* ^?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1) /* ^?{} */);
+    }
+
+}
 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
-          struct S _X4_retS1S_1;
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
-          }
-
-          return _X4_retS1S_1;
-        }
+    struct S _X4_retS1S_1;
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1=_X4_srcS1S_1._X1ai_1));
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1=_X4_srcS1S_1._X1bi_1));
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1=_X4_srcS1S_1._X1ci_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
+    }
+
+    return _X4_retS1S_1;
+}
 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S1Sii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S1Siii_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ai_1, signed int _X1bi_1, signed int _X1ci_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
-          }
-
-          {
-            ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ai_1=_X1ai_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1bi_1=_X1bi_1) /* ?{} */);
+    }
+
+    {
+        ((void)((*_X4_dstS1S_1)._X1ci_1=_X1ci_1) /* ?{} */);
+    }
+
+}
 __extension__ union U {
-          __extension__ signed int _X1ai_1;
-          __extension__ signed int _X1bi_1;
-          __extension__ signed int _X1ci_1;
-        };
+    __extension__ signed int _X1ai_1;
+    __extension__ signed int _X1bi_1;
+    __extension__ signed int _X1ci_1;
+};
 static inline void _X12_constructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1);
 static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1);
@@ -129 +129 @@
 static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1);
 static inline void _X12_constructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
-        }
+}
 static inline void _X12_constructorFv_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
-          {
-            ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
-          }
-
-        }
+    {
+        ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
+    }
+
+}
 static inline void _X11_destructorFv_U1U_autogen___1(__attribute__ ((unused)) union U *_X4_dstU1U_1){
-        }
+}
 static inline union U _X16_operator_assignFU1U_U1UU1U_autogen___1(union U *_X4_dstU1U_1, union U _X4_srcU1U_1){
-          union U _X4_retU1U_1;
-          {
-            ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
-          }
-
-          {
-            ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
-          }
-
-          return _X4_retU1U_1;
-        }
+    union U _X4_retU1U_1;
+    {
+        ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X4_srcU1U_1)), sizeof(union U )));
+    }
+
+    {
+        ((void)_X12_constructorFv_U1UU1U_autogen___1((&_X4_retU1U_1), (*_X4_dstU1U_1)));
+    }
+
+    return _X4_retU1U_1;
+}
 static inline void _X12_constructorFv_U1Ui_autogen___1(union U *_X4_dstU1U_1, signed int _X1ai_1){
-          {
-            ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
-          }
-
-        }
+    {
+        ((void)__builtin_memcpy(((void *)_X4_dstU1U_1), ((const void *)(&_X1ai_1)), sizeof(signed int )));
+    }
+
+}
 __extension__ enum E {
-          _X1RKM1E_1,
-          _X1GKM1E_1,
-          _X1BKM1E_1,
-        };
+    _X1RKM1E_1,
+    _X1GKM1E_1,
+    _X1BKM1E_1,
+};
 __extension__ signed int _X1fFi___1();
 __extension__ signed int i;
 __extension__ signed int j;
 __extension__ signed int _X4fredFi_i__1(signed int _X1pi_1){
-          __attribute__ ((unused)) signed int _X12_retval_fredi_1;
-          __extension__ struct S {
-            __extension__ signed int _X1ai_2;
-            __extension__ signed int _X1bi_2;
-            __extension__ signed int _X1ci_2;
-            __extension__ signed int *_X1xPi_2;
-            __extension__ signed int *_X1yPi_2;
-            __extension__ signed int *_X1zPi_2;
-          };
-          inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
-            }
-
-          }
-          inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
-            struct S _X4_retS1S_2;
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
-            }
-
-            {
-              ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
-            }
-
-            return _X4_retS1S_2;
-          }
-          inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1SiiiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1SiiiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1SiiiPiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2, signed int *_X1zPi_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
-            }
-
-          }
-          signed int _X1ii_2 = (__extension__ _X1ai_1+__extension__ 3);
-          {
-            ((void)__extension__ 3);
-          }
-
-          {
-            ((void)__extension__ _X1ai_1);
-          }
-
-          __extension__ signed int _X1ai_2;
-          __extension__ signed int _X1bi_2;
-          __extension__ signed int _X1ci_2;
-          {
-            ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
-          }
-
-          {
-            signed int _tmp_cp_ret4;
-            ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
-          }
-
-          __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){
-            __attribute__ ((unused)) signed int _X12_retval_maryi_2;
-          }
-          {
-            ((void)__extension__ sizeof(3));
-          }
-
-          {
-            ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
-          }
-
-          {
-            ((void)__extension__ __alignof__(__extension__ _X1ai_2));
-          }
-
-          {
-            ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
-          }
-
-          {
-            ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
-          }
-
-          {
-            ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
-          }
-
-          {
-            ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
-          }
-
-        }
+    __attribute__ ((unused)) signed int _X12_retval_fredi_1;
+    __extension__ struct S {
+        __extension__ signed int _X1ai_2;
+        __extension__ signed int _X1bi_2;
+        __extension__ signed int _X1ci_2;
+        __extension__ signed int *_X1xPi_2;
+        __extension__ signed int *_X1yPi_2;
+        __extension__ signed int *_X1zPi_2;
+    };
+    inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
+        }
+
+    }
+    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
+        struct S _X4_retS1S_2;
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2=_X4_srcS1S_2._X1xPi_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2=_X4_srcS1S_2._X1yPi_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2=_X4_srcS1S_2._X1zPi_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
+        }
+
+        return _X4_retS1S_2;
+    }
+    inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SiiiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SiiiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SiiiPiPiPi_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2, signed int *_X1xPi_2, signed int *_X1yPi_2, signed int *_X1zPi_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1xPi_2=_X1xPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1yPi_2=_X1yPi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1zPi_2=_X1zPi_2) /* ?{} */);
+        }
+
+    }
+    signed int _X1ii_2 = (__extension__ _X1ai_1+__extension__ 3);
+    {
+        ((void)__extension__ 3);
+    }
+
+    {
+        ((void)__extension__ _X1ai_1);
+    }
+
+    __extension__ signed int _X1ai_2;
+    __extension__ signed int _X1bi_2;
+    __extension__ signed int _X1ci_2;
+    {
+        ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
+    }
+
+    {
+        signed int _tmp_cp_ret4;
+        ((void)(((void)(_tmp_cp_ret4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4));
+    }
+
+    __extension__ signed int _X4maryFi_i__2(signed int _X1pi_2){
+        __attribute__ ((unused)) signed int _X12_retval_maryi_2;
+    }
+    {
+        ((void)__extension__ sizeof(3));
+    }
+
+    {
+        ((void)__extension__ ((3!=((signed int )0)) || (4!=((signed int )0))));
+    }
+
+    {
+        ((void)__extension__ __alignof__(__extension__ _X1ai_2));
+    }
+
+    {
+        ((void)((__extension__ _X1ai_2!=((signed int )0)) || (((__extension__ _X1bi_2!=((signed int )0)) && (__extension__ _X1ci_2!=((signed int )0)))!=((signed int )0))));
+    }
+
+    {
+        ((void)(((__extension__ _X1ai_2>__extension__ _X1bi_2)!=((signed int )0)) ? __extension__ _X1ci_2 : __extension__ _X1ci_2));
+    }
+
+    {
+        ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
+    }
+
+    {
+        ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
+    }
+
+}

tests/.expect/functions.x64.txt

@@ -1 +1 @@
 void _X1hFv___1(void){
-        }
+}
 signed int _X1fFi_Fi__Fi_i_Fi__Fi_i_Fv____1(__attribute__ ((unused)) signed int (*__anonymous_object0)(void), __attribute__ ((unused)) signed int (*__anonymous_object1)(signed int __anonymous_object2), __attribute__ ((unused)) signed int (*__anonymous_object3)(void), __attribute__ ((unused)) signed int (*__anonymous_object4)(signed int __anonymous_object5), void (*_X1gFv___1)(void)){
-          __attribute__ ((unused)) signed int _X9_retval_fi_1;
-          {
-            ((void)(*_X1gFv___1)());
-          }
-
-          {
-            ((void)_X1gFv___1());
-          }
-
-          {
-            ((void)(_X1gFv___1=_X1hFv___1));
-          }
-
-        }
+    __attribute__ ((unused)) signed int _X9_retval_fi_1;
+    {
+        ((void)(*_X1gFv___1)());
+    }
+
+    {
+        ((void)_X1gFv___1());
+    }
+
+    {
+        ((void)(_X1gFv___1=_X1hFv___1));
+    }
+
+}
 signed int _X2f1Fi___1(){
-          __attribute__ ((unused)) signed int _X10_retval_f1i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f1i_1;
+}
 signed int _X2f2Fi___1(){
-          __attribute__ ((unused)) signed int _X10_retval_f2i_1;
-        }
+    __attribute__ ((unused)) signed int _X10_retval_f2i_1;
+}
 signed int (*_X2f3FFi_____1())(){
-          __attribute__ ((unused)) signed int (*_X10_retval_f3Fi___1)();
-        }
+    __attribute__ ((unused)) signed int (*_X10_retval_f3Fi___1)();
+}
 signed int *_X2f4FPi___1(){
-          __attribute__ ((unused)) signed int *_X10_retval_f4Pi_1;
-        }
+    __attribute__ ((unused)) signed int *_X10_retval_f4Pi_1;
+}
 signed int (*_X2f5FFi_____1())(){
-          __attribute__ ((unused)) signed int (*_X10_retval_f5Fi___1)();
-        }
+    __attribute__ ((unused)) signed int (*_X10_retval_f5Fi___1)();
+}
 signed int *_X2f6FPi___1(){
-          __attribute__ ((unused)) signed int *_X10_retval_f6Pi_1;
-        }
+    __attribute__ ((unused)) signed int *_X10_retval_f6Pi_1;
+}
 signed int *_X2f7FPi___1(){
-          __attribute__ ((unused)) signed int *_X10_retval_f7Pi_1;
-        }
+    __attribute__ ((unused)) signed int *_X10_retval_f7Pi_1;
+}
 signed int **_X2f8FPPi___1(){
-          __attribute__ ((unused)) signed int **_X10_retval_f8PPi_1;
-        }
+    __attribute__ ((unused)) signed int **_X10_retval_f8PPi_1;
+}
 signed int *const *_X2f9FPKPi___1(){
-          __attribute__ ((unused)) signed int *const *_X10_retval_f9PKPi_1;
-        }
+    __attribute__ ((unused)) signed int *const *_X10_retval_f9PKPi_1;
+}
 signed int (*_X3f10FPA0i___1())[]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f10PA0i_1)[];
+}
 signed int (*_X3f11FPA0A0i___1())[][((unsigned long int )3)]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned long int )3)];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f11PA0A0i_1)[][((unsigned long int )3)];
+}
 signed int (*_X3f12FPA0A0i___1())[][((unsigned long int )3)]{
-          __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )3)];
-        }
+    __attribute__ ((unused)) signed int (*_X11_retval_f12PA0A0i_1)[][((unsigned long int )3)];
+}
 signed int _X4fII1Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) signed int _X12_retval_fII1i_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_fII1i_1;
+}
 const signed int _X4fII2Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) const signed int _X12_retval_fII2Ki_1;
-        }
+    __attribute__ ((unused)) const signed int _X12_retval_fII2Ki_1;
+}
 extern signed int _X4fII3Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) signed int _X12_retval_fII3i_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_fII3i_1;
+}
 extern const signed int _X4fII4Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) const signed int _X12_retval_fII4Ki_1;
-        }
+    __attribute__ ((unused)) const signed int _X12_retval_fII4Ki_1;
+}
 signed int *_X4fII5FPi___1(){
-          __attribute__ ((unused)) signed int *_X12_retval_fII5Pi_1;
-        }
+    __attribute__ ((unused)) signed int *_X12_retval_fII5Pi_1;
+}
 signed int *const _X4fII6FPi___1(){
-          __attribute__ ((unused)) signed int *const _X12_retval_fII6KPi_1;
-        }
+    __attribute__ ((unused)) signed int *const _X12_retval_fII6KPi_1;
+}
 const signed long int *_X4fII7FPKl___1(){
-          __attribute__ ((unused)) const signed long int *_X12_retval_fII7PKl_1;
-        }
+    __attribute__ ((unused)) const signed long int *_X12_retval_fII7PKl_1;
+}
 static const signed long int *_X4fII8FPKl___1(){
-          __attribute__ ((unused)) const signed long int *_X12_retval_fII8PKl_1;
-        }
+    __attribute__ ((unused)) const signed long int *_X12_retval_fII8PKl_1;
+}
 static const signed long int *_X4fII9FPKl___1(){
-          __attribute__ ((unused)) const signed long int *_X12_retval_fII9PKl_1;
-        }
+    __attribute__ ((unused)) const signed long int *_X12_retval_fII9PKl_1;
+}
 signed int _X3fO1Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) signed int _X11_retval_fO1i_1;
-        }
+    __attribute__ ((unused)) signed int _X11_retval_fO1i_1;
+}
 signed int _X3fO2Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) signed int _X11_retval_fO2i_1;
-        }
+    __attribute__ ((unused)) signed int _X11_retval_fO2i_1;
+}
 const signed int _X3fO3Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) const signed int _X11_retval_fO3Ki_1;
-        }
+    __attribute__ ((unused)) const signed int _X11_retval_fO3Ki_1;
+}
 extern signed int _X3fO4Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) signed int _X11_retval_fO4i_1;
-        }
+    __attribute__ ((unused)) signed int _X11_retval_fO4i_1;
+}
 extern const signed int _X3fO5Fi_i__1(signed int _X1ii_1){
-          __attribute__ ((unused)) const signed int _X11_retval_fO5Ki_1;
-        }
+    __attribute__ ((unused)) const signed int _X11_retval_fO5Ki_1;
+}
 signed int _X1fFi___1(void);
 signed int _X1fFi_i__1(signed int __anonymous_object6);
 signed int _X1fFi___1(void){
-          __attribute__ ((unused)) signed int _X9_retval_fi_1;
-        }
+    __attribute__ ((unused)) signed int _X9_retval_fi_1;
+}
 signed int _X1fFi_i__1(__attribute__ ((unused)) signed int __anonymous_object7){
-          __attribute__ ((unused)) signed int _X9_retval_fi_1;
-        }
+    __attribute__ ((unused)) signed int _X9_retval_fi_1;
+}
 signed int _X1fFi___1(void);
 struct _tuple2_ {
-        };
+};
 static inline void _layoutof__tuple2_(unsigned long int *_sizeof__tuple2_, unsigned long int *_alignof__tuple2_, unsigned long int *_offsetof__tuple2_, unsigned long int _sizeof_Y15tuple_param_2_0, unsigned long int _alignof_Y15tuple_param_2_0, unsigned long int _sizeof_Y15tuple_param_2_1, unsigned long int _alignof_Y15tuple_param_2_1){
-          ((void)((*_sizeof__tuple2_)=0));
-          ((void)((*_alignof__tuple2_)=1));
-          ((void)(_offsetof__tuple2_[0]=(*_sizeof__tuple2_)));
-          ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_0));
-          if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_0) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_0));
-
-          if ( ((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)) ) ((void)((*_sizeof__tuple2_)+=(_alignof_Y15tuple_param_2_1-((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)))));
-
-          ((void)(_offsetof__tuple2_[1]=(*_sizeof__tuple2_)));
-          ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_1));
-          if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_1) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_1));
-
-          if ( ((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)) ) ((void)((*_sizeof__tuple2_)+=((*_alignof__tuple2_)-((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)))));
-
-        }
+    ((void)((*_sizeof__tuple2_)=0));
+    ((void)((*_alignof__tuple2_)=1));
+    ((void)(_offsetof__tuple2_[0]=(*_sizeof__tuple2_)));
+    ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_0));
+    if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_0) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_0));
+
+    if ( ((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)) ) ((void)((*_sizeof__tuple2_)+=(_alignof_Y15tuple_param_2_1-((*_sizeof__tuple2_)&(_alignof_Y15tuple_param_2_1-1)))));
+
+    ((void)(_offsetof__tuple2_[1]=(*_sizeof__tuple2_)));
+    ((void)((*_sizeof__tuple2_)+=_sizeof_Y15tuple_param_2_1));
+    if ( ((*_alignof__tuple2_)<_alignof_Y15tuple_param_2_1) ) ((void)((*_alignof__tuple2_)=_alignof_Y15tuple_param_2_1));
+
+    if ( ((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)) ) ((void)((*_sizeof__tuple2_)+=((*_alignof__tuple2_)-((*_sizeof__tuple2_)&((*_alignof__tuple2_)-1)))));
+
+}
 struct _conc__tuple2_0 {
-          signed int field_0;
-          signed int field_1;
-        };
+    signed int field_0;
+    signed int field_1;
+};
 struct _conc__tuple2_0 _X1fFT2ii___1(void);
 struct _conc__tuple2_0 _X1fFT2ii_ii__1(signed int __anonymous_object8, signed int _X1xi_1);
 struct _conc__tuple2_0 _X1fFT2ii___1(void){
-          __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
-        }
+    __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
+}
 struct _conc__tuple2_0 _X1fFT2ii_ii__1(__attribute__ ((unused)) signed int __anonymous_object9, signed int _X1xi_1){
-          __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
-        }
+    __attribute__ ((unused)) struct _conc__tuple2_0 _X9_retval_fT2ii_1 = {  };
+}
 struct _tuple3_ {
-        };
+};
 static inline void _layoutof__tuple3_(unsigned long int *_sizeof__tuple3_, unsigned long int *_alignof__tuple3_, unsigned long int *_offsetof__tuple3_, unsigned long int _sizeof_Y15tuple_param_3_0, unsigned long int _alignof_Y15tuple_param_3_0, unsigned long int _sizeof_Y15tuple_param_3_1, unsigned long int _alignof_Y15tuple_param_3_1, unsigned long int _sizeof_Y15tuple_param_3_2, unsigned long int _alignof_Y15tuple_param_3_2){
-          ((void)((*_sizeof__tuple3_)=0));
-          ((void)((*_alignof__tuple3_)=1));
-          ((void)(_offsetof__tuple3_[0]=(*_sizeof__tuple3_)));
-          ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_0));
-          if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_0) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_0));
-
-          if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_1-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)))));
-
-          ((void)(_offsetof__tuple3_[1]=(*_sizeof__tuple3_)));
-          ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_1));
-          if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_1) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_1));
-
-          if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_2-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)))));
-
-          ((void)(_offsetof__tuple3_[2]=(*_sizeof__tuple3_)));
-          ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_2));
-          if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_2) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_2));
-
-          if ( ((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)) ) ((void)((*_sizeof__tuple3_)+=((*_alignof__tuple3_)-((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)))));
-
-        }
+    ((void)((*_sizeof__tuple3_)=0));
+    ((void)((*_alignof__tuple3_)=1));
+    ((void)(_offsetof__tuple3_[0]=(*_sizeof__tuple3_)));
+    ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_0));
+    if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_0) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_0));
+
+    if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_1-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_1-1)))));
+
+    ((void)(_offsetof__tuple3_[1]=(*_sizeof__tuple3_)));
+    ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_1));
+    if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_1) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_1));
+
+    if ( ((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)) ) ((void)((*_sizeof__tuple3_)+=(_alignof_Y15tuple_param_3_2-((*_sizeof__tuple3_)&(_alignof_Y15tuple_param_3_2-1)))));
+
+    ((void)(_offsetof__tuple3_[2]=(*_sizeof__tuple3_)));
+    ((void)((*_sizeof__tuple3_)+=_sizeof_Y15tuple_param_3_2));
+    if ( ((*_alignof__tuple3_)<_alignof_Y15tuple_param_3_2) ) ((void)((*_alignof__tuple3_)=_alignof_Y15tuple_param_3_2));
+
+    if ( ((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)) ) ((void)((*_sizeof__tuple3_)+=((*_alignof__tuple3_)-((*_sizeof__tuple3_)&((*_alignof__tuple3_)-1)))));
+
+}
 struct _conc__tuple3_1 {
-          signed int field_0;
-          signed int field_1;
-          signed int field_2;
-        };
+    signed int field_0;
+    signed int field_1;
+    signed int field_2;
+};
 struct _conc__tuple3_1 _X1fFT3iii___1(void);
 struct _conc__tuple3_1 _X1fFT3iii_iii__1(signed int __anonymous_object10, signed int _X1xi_1, signed int __anonymous_object11);
 struct _conc__tuple3_1 _X1fFT3iii___1(void){
-          __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
-        }
+    __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
+}
 struct _conc__tuple3_1 _X1fFT3iii_iii__1(__attribute__ ((unused)) signed int __anonymous_object12, signed int _X1xi_1, __attribute__ ((unused)) signed int __anonymous_object13){
-          __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
-        }
+    __attribute__ ((unused)) struct _conc__tuple3_1 _X9_retval_fT3iii_1 = {  };
+}
 struct _conc__tuple3_2 {
-          signed int field_0;
-          signed int field_1;
-          signed int *field_2;
-        };
+    signed int field_0;
+    signed int field_1;
+    signed int *field_2;
+};
 struct _conc__tuple3_2 _X1fFT3iiPi___1(void);
 struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(signed int __anonymous_object14, signed int _X1xi_1, signed int *_X1yPi_1);
 struct _conc__tuple3_2 _X1fFT3iiPi___1(void){
-          __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
-        }
+    __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
+}
 struct _conc__tuple3_2 _X1fFT3iiPi_iiPi__1(__attribute__ ((unused)) signed int __anonymous_object15, signed int _X1xi_1, signed int *_X1yPi_1){
-          __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
-        }
+    __attribute__ ((unused)) struct _conc__tuple3_2 _X9_retval_fT3iiPi_1 = {  };
+}
 signed int _X3f11Fi_i__1(signed int __anonymous_object16);
 signed int _X3f12Fi___1(void);
@@ -191 +191 @@
 const double _X3fooFd_i__1(signed int __anonymous_object19);
 const double _X3fooFd_d__1(__attribute__ ((unused)) double __anonymous_object20){
-          __attribute__ ((unused)) const double _X11_retval_fooKd_1;
-          {
-            ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
-          }
-
-          return _X11_retval_fooKd_1;
-        }
+    __attribute__ ((unused)) const double _X11_retval_fooKd_1;
+    {
+        ((void)((*((double *)(&_X11_retval_fooKd_1)))=3.0) /* ?{} */);
+    }
+
+    return _X11_retval_fooKd_1;
+}
 struct S {
-          signed int _X1ii_1;
-        };
+    signed int _X1ii_1;
+};
 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1);
 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1);
@@ -207 +207 @@
 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1);
 static inline void _X12_constructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X12_constructorFv_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1) /* ?{} */);
+    }
+
+}
 static inline void _X11_destructorFv_S1S_autogen___1(struct S *_X4_dstS1S_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1) /* ^?{} */);
+    }
+
+}
 static inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___1(struct S *_X4_dstS1S_1, struct S _X4_srcS1S_1){
-          struct S _X4_retS1S_1;
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
-          }
-
-          {
-            ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
-          }
-
-          return _X4_retS1S_1;
-        }
+    struct S _X4_retS1S_1;
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1=_X4_srcS1S_1._X1ii_1));
+    }
+
+    {
+        ((void)_X12_constructorFv_S1SS1S_autogen___1((&_X4_retS1S_1), (*_X4_dstS1S_1)));
+    }
+
+    return _X4_retS1S_1;
+}
 static inline void _X12_constructorFv_S1Si_autogen___1(struct S *_X4_dstS1S_1, signed int _X1ii_1){
-          {
-            ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
-          }
-
-        }
+    {
+        ((void)((*_X4_dstS1S_1)._X1ii_1=_X1ii_1) /* ?{} */);
+    }
+
+}
 struct S _X3rtnFS1S_i__1(__attribute__ ((unused)) signed int __anonymous_object21){
-          __attribute__ ((unused)) struct S _X11_retval_rtnS1S_1;
-        }
+    __attribute__ ((unused)) struct S _X11_retval_rtnS1S_1;
+}
 signed int _X1fFi_Fi_ii_Fi_i___1(__attribute__ ((unused)) signed int (*__anonymous_object22)(signed int __anonymous_object23, signed int _X1pi_1), __attribute__ ((unused)) signed int (*__anonymous_object24)(signed int __anonymous_object25)){
-          __attribute__ ((unused)) signed int _X9_retval_fi_1;
-          signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
-          signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
-          signed int (*(*_X1pPA0Fi_i__2)[])(signed int __anonymous_object26);
-        }
+    __attribute__ ((unused)) signed int _X9_retval_fi_1;
+    signed int (*(*_X2pcPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
+    signed int (*(*_X1pPA0A0PA0A0i_2)[][((unsigned long int )10)])[][((unsigned long int )3)];
+    signed int (*(*_X1pPA0Fi_i__2)[])(signed int __anonymous_object26);
+}
 static const signed int *_X2f1FPKi___1(){
-          __attribute__ ((unused)) const signed int *_X10_retval_f1PKi_1;
-        }
+    __attribute__ ((unused)) const signed int *_X10_retval_f1PKi_1;
+}
 static const signed int *_X2f2FPKi___1(void){
-          __attribute__ ((unused)) const signed int *_X10_retval_f2PKi_1;
-        }
+    __attribute__ ((unused)) const signed int *_X10_retval_f2PKi_1;
+}
 static inline signed int *const _X2f3FPi___1(void){
-          __attribute__ ((unused)) signed int *const _X10_retval_f3KPi_1;
-        }
+    __attribute__ ((unused)) signed int *const _X10_retval_f3KPi_1;
+}
 struct _conc__tuple2_3 {
-          signed int *field_0;
-          signed int field_1;
-        };
+    signed int *field_0;
+    signed int field_1;
+};
 static inline const struct _conc__tuple2_3 _X2f4FT2Pii___1(void){
-          __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f4KT2Pii_1;
-        }
+    __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f4KT2Pii_1;
+}
 static const struct _conc__tuple2_3 _X2f5FT2PiKi___1(void){
-          __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f5KT2PiKi_1;
-        }
+    __attribute__ ((unused)) const struct _conc__tuple2_3 _X10_retval_f5KT2PiKi_1;
+}
 signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(signed int (*__anonymous_object27)(), signed int *(*__anonymous_object28)(), signed int **(*__anonymous_object29)(), signed int *const *(*__anonymous_object30)(), signed int *const *const (*__anonymous_object31)(), signed int *__anonymous_object32, signed int __anonymous_object33[((unsigned long int )10)], signed int **__anonymous_object34, signed int *__anonymous_object35[((unsigned long int )10)], signed int ***__anonymous_object36, signed int **__anonymous_object37[((unsigned long int )10)], signed int *const **__anonymous_object38, signed int *const *__anonymous_object39[((unsigned long int )10)], signed int *const *const *__anonymous_object40, signed int *const *const __anonymous_object41[((unsigned long int )10)]);
 signed int _X1fFi_Fi__FPi__FPPi__FPKPi__FPKPi__PiPiPPiPPiPPPiPPPiPPKPiPPKPiPKPKPiPKPKPi__1(__attribute__ ((unused)) signed int (*__anonymous_object42)(), __attribute__ ((unused)) signed int *(*__anonymous_object43)(), __attribute__ ((unused)) signed int **(*__anonymous_object44)(), __attribute__ ((unused)) signed int *const *(*__anonymous_object45)(), __attribute__ ((unused)) signed int *const *const (*__anonymous_object46)(), __attribute__ ((unused)) signed int *__anonymous_object47, __attribute__ ((unused)) signed int __anonymous_object48[((unsigned long int )10)], __attribute__ ((unused)) signed int **__anonymous_object49, __attribute__ ((unused)) signed int *__anonymous_object50[((unsigned long int )10)], __attribute__ ((unused)) signed int ***__anonymous_object51, __attribute__ ((unused)) signed int **__anonymous_object52[((unsigned long int )10)], __attribute__ ((unused)) signed int *const **__anonymous_object53, __attribute__ ((unused)) signed int *const *__anonymous_object54[((unsigned long int )10)], __attribute__ ((unused)) signed int *const *const *__anonymous_object55, __attribute__ ((unused)) signed int *const *const __anonymous_object56[((unsigned long int )10)]){
-          __attribute__ ((unused)) signed int _X9_retval_fi_1;
-        }
+    __attribute__ ((unused)) signed int _X9_retval_fi_1;
+}
 signed int _X1fFi_Pii__1(signed int *_X1fPi_1, signed int _X1ti_1){
-          __attribute__ ((unused)) signed int _X9_retval_fi_1;
-          signed int _X1Ti_2;
-        }
+    __attribute__ ((unused)) signed int _X9_retval_fi_1;
+    signed int _X1Ti_2;
+}

tests/.expect/gccExtensions.x64.txt

@@ -1 +1 @@
 extern signed int _X1xi_1 asm ( "xx" );
 signed int _X4mainFi_iPPKc__1(signed int _X4argci_1, const char **_X4argvPPKc_1){
-          __attribute__ ((unused)) signed int _X12_retval_maini_1;
-          asm ( "nop" :  :  :  );
-          asm ( "nop" :  :  :  );
-          asm ( "nop" :  :  :  );
-          static signed int _X1yi_2 asm ( "yy" );
-          static signed int *_X1zPi_2 asm ( "zz" );
-          signed int _X3srci_2;
-          signed int _X3dsti_2;
-          asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
-          asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) :  :  );
-          asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) :  );
-          asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
-          L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
-          double _Complex _X2c1Cd_2;
-          double _Complex _X2c2Cd_2;
-          const signed int _X2i1Ki_2;
-          const signed int _X2i2Ki_2;
-          const signed int _X2i3Ki_2;
-          inline signed int _X2f1Fi___2(){
-            __attribute__ ((unused)) signed int _X10_retval_f1i_2;
-          }
-          inline signed int _X2f2Fi___2(){
-            __attribute__ ((unused)) signed int _X10_retval_f2i_2;
-          }
-          signed int _X2s1i_2;
-          signed int _X2s2i_2;
-          volatile signed int _X2v1Vi_2;
-          volatile signed int _X2v2Vi_2;
-          signed int _X2t1i_2;
-          signed int _X2t2i_2;
-          __extension__ const signed int _X2exKi_2;
-          struct S {
-            __extension__ signed int _X1ai_2;
-            __extension__ signed int _X1bi_2;
-            __extension__ signed int _X1ci_2;
-          };
-          inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
-            }
-
-          }
-          inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
-            struct S _X4_retS1S_2;
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
-            }
-
-            {
-              ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
-            }
-
-            return _X4_retS1S_2;
-          }
-          inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
-            {
-              ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
-            }
-
-            {
-              ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
-            }
-
-          }
-          signed int _X1ii_2 = __extension__ 3;
-          __extension__ signed int _X1ai_2;
-          __extension__ signed int _X1bi_2;
-          __extension__ signed int _X1ci_2;
-          {
-            ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
-          }
-
-          {
-            ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
-          }
-
-          {
-            ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
-          }
-
-          signed int _X2a1i_2;
-          const signed int _X2a2Ki_2;
-          static const signed int _X2a3Ki_2;
-          static const signed int _X2a4Ki_2;
-          static const signed int _X2a5Ki_2;
-          static const signed int _X2a6Ki_2;
-          static const signed int _X2a7Ki_2;
-          signed int *_X2p1Pi_2;
-          signed int *_X2p2Pi_2;
-          struct s1;
-          struct s2 {
-            signed int _X1ii_2;
-          };
-          inline void _X12_constructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
-            {
-              ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
-            {
-              ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
-            {
-              ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
-            }
-
-          }
-          inline struct s2 _X16_operator_assignFS2s2_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
-            struct s2 _X4_retS2s2_2;
-            {
-              ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
-            }
-
-            {
-              ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
-            }
-
-            return _X4_retS2s2_2;
-          }
-          inline void _X12_constructorFv_S2s2i_autogen___2(struct s2 *_X4_dstS2s2_2, signed int _X1ii_2){
-            {
-              ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
-            }
-
-          }
-          struct s3 {
-            signed int _X1ii_2;
-          };
-          inline void _X12_constructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
-            {
-              ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
-            {
-              ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
-            {
-              ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
-            }
-
-          }
-          inline struct s3 _X16_operator_assignFS2s3_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
-            struct s3 _X4_retS2s3_2;
-            {
-              ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
-            }
-
-            {
-              ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
-            }
-
-            return _X4_retS2s3_2;
-          }
-          inline void _X12_constructorFv_S2s3i_autogen___2(struct s3 *_X4_dstS2s3_2, signed int _X1ii_2){
-            {
-              ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
-            }
-
-          }
-          struct s3 _X2x1S2s3_2;
-          struct s3 _X2y1S2s3_2;
-          struct s4 {
-            signed int _X1ii_2;
-          };
-          inline void _X12_constructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
-            {
-              ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X12_constructorFv_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
-            {
-              ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
-            }
-
-          }
-          inline void _X11_destructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
-            {
-              ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
-            }
-
-          }
-          inline struct s4 _X16_operator_assignFS2s4_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
-            struct s4 _X4_retS2s4_2;
-            {
-              ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
-            }
-
-            {
-              ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
-            }
-
-            return _X4_retS2s4_2;
-          }
-          inline void _X12_constructorFv_S2s4i_autogen___2(struct s4 *_X4_dstS2s4_2, signed int _X1ii_2){
-            {
-              ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
-            }
-
-          }
-          struct s4 _X2x2S2s4_2;
-          struct s4 _X2y2S2s4_2;
-          signed int _X2m1A0i_2[((unsigned long int )10)];
-          signed int _X2m2A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
-          signed int _X2m3A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
-          {
-            ((void)(_X12_retval_maini_1=0) /* ?{} */);
-          }
-
-          return _X12_retval_maini_1;
-          {
-            ((void)(_X12_retval_maini_1=0) /* ?{} */);
-          }
-
-          return _X12_retval_maini_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_maini_1;
+    asm ( "nop" :  :  :  );
+    asm ( "nop" :  :  :  );
+    asm ( "nop" :  :  :  );
+    static signed int _X1yi_2 asm ( "yy" );
+    static signed int *_X1zPi_2 asm ( "zz" );
+    signed int _X3srci_2;
+    signed int _X3dsti_2;
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" :  :  :  );
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=" "r" ( _X3dsti_2 ) :  :  );
+    asm volatile ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ) : "r" ( _X3srci_2 ) :  );
+    asm ( "mov %1, %0\n\t" "add $1, %0" : "=r" ( _X3dsti_2 ), "=r" ( _X3srci_2 ) : [ _X3srci_2 ] "r" ( _X3dsti_2 ) : "r0" );
+    L2: L1: asm goto ( "frob %%r5, %1; jc %l[L1]; mov (%2), %%r5" :  : "r" ( _X3srci_2 ), "r" ( (&_X3dsti_2) ) : "r5", "memory" : L1, L2 );
+    double _Complex _X2c1Cd_2;
+    double _Complex _X2c2Cd_2;
+    const signed int _X2i1Ki_2;
+    const signed int _X2i2Ki_2;
+    const signed int _X2i3Ki_2;
+    inline signed int _X2f1Fi___2(){
+        __attribute__ ((unused)) signed int _X10_retval_f1i_2;
+    }
+    inline signed int _X2f2Fi___2(){
+        __attribute__ ((unused)) signed int _X10_retval_f2i_2;
+    }
+    signed int _X2s1i_2;
+    signed int _X2s2i_2;
+    volatile signed int _X2v1Vi_2;
+    volatile signed int _X2v2Vi_2;
+    signed int _X2t1i_2;
+    signed int _X2t2i_2;
+    __extension__ const signed int _X2exKi_2;
+    struct S {
+        __extension__ signed int _X1ai_2;
+        __extension__ signed int _X1bi_2;
+        __extension__ signed int _X1ci_2;
+    };
+    inline void _X12_constructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S1S_autogen___2(struct S *_X4_dstS1S_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2) /* ^?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2) /* ^?{} */);
+        }
+
+    }
+    inline struct S _X16_operator_assignFS1S_S1SS1S_autogen___2(struct S *_X4_dstS1S_2, struct S _X4_srcS1S_2){
+        struct S _X4_retS1S_2;
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X4_srcS1S_2._X1ai_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X4_srcS1S_2._X1bi_2));
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X4_srcS1S_2._X1ci_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S1SS1S_autogen___2((&_X4_retS1S_2), (*_X4_dstS1S_2)));
+        }
+
+        return _X4_retS1S_2;
+    }
+    inline void _X12_constructorFv_S1Si_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1Sii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S1Siii_autogen___2(struct S *_X4_dstS1S_2, signed int _X1ai_2, signed int _X1bi_2, signed int _X1ci_2){
+        {
+            ((void)((*_X4_dstS1S_2)._X1ai_2=_X1ai_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1bi_2=_X1bi_2) /* ?{} */);
+        }
+
+        {
+            ((void)((*_X4_dstS1S_2)._X1ci_2=_X1ci_2) /* ?{} */);
+        }
+
+    }
+    signed int _X1ii_2 = __extension__ 3;
+    __extension__ signed int _X1ai_2;
+    __extension__ signed int _X1bi_2;
+    __extension__ signed int _X1ci_2;
+    {
+        ((void)(((void)(((void)__extension__ _X1ai_2) , __extension__ _X1bi_2)) , __extension__ _X1ci_2));
+    }
+
+    {
+        ((void)(__extension__ _X1ai_2=(__extension__ _X1bi_2+__extension__ _X1ci_2)));
+    }
+
+    {
+        ((void)(__extension__ _X1ai_2=__extension__ (__extension__ _X1bi_2+__extension__ _X1ci_2)));
+    }
+
+    signed int _X2a1i_2;
+    const signed int _X2a2Ki_2;
+    static const signed int _X2a3Ki_2;
+    static const signed int _X2a4Ki_2;
+    static const signed int _X2a5Ki_2;
+    static const signed int _X2a6Ki_2;
+    static const signed int _X2a7Ki_2;
+    signed int *_X2p1Pi_2;
+    signed int *_X2p2Pi_2;
+    struct s1;
+    struct s2 {
+        signed int _X1ii_2;
+    };
+    inline void _X12_constructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
+        {
+            ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
+        {
+            ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S2s2_autogen___2(struct s2 *_X4_dstS2s2_2){
+        {
+            ((void)((*_X4_dstS2s2_2)._X1ii_2) /* ^?{} */);
+        }
+
+    }
+    inline struct s2 _X16_operator_assignFS2s2_S2s2S2s2_autogen___2(struct s2 *_X4_dstS2s2_2, struct s2 _X4_srcS2s2_2){
+        struct s2 _X4_retS2s2_2;
+        {
+            ((void)((*_X4_dstS2s2_2)._X1ii_2=_X4_srcS2s2_2._X1ii_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S2s2S2s2_autogen___2((&_X4_retS2s2_2), (*_X4_dstS2s2_2)));
+        }
+
+        return _X4_retS2s2_2;
+    }
+    inline void _X12_constructorFv_S2s2i_autogen___2(struct s2 *_X4_dstS2s2_2, signed int _X1ii_2){
+        {
+            ((void)((*_X4_dstS2s2_2)._X1ii_2=_X1ii_2) /* ?{} */);
+        }
+
+    }
+    struct s3 {
+        signed int _X1ii_2;
+    };
+    inline void _X12_constructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
+        {
+            ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
+        {
+            ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S2s3_autogen___2(struct s3 *_X4_dstS2s3_2){
+        {
+            ((void)((*_X4_dstS2s3_2)._X1ii_2) /* ^?{} */);
+        }
+
+    }
+    inline struct s3 _X16_operator_assignFS2s3_S2s3S2s3_autogen___2(struct s3 *_X4_dstS2s3_2, struct s3 _X4_srcS2s3_2){
+        struct s3 _X4_retS2s3_2;
+        {
+            ((void)((*_X4_dstS2s3_2)._X1ii_2=_X4_srcS2s3_2._X1ii_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S2s3S2s3_autogen___2((&_X4_retS2s3_2), (*_X4_dstS2s3_2)));
+        }
+
+        return _X4_retS2s3_2;
+    }
+    inline void _X12_constructorFv_S2s3i_autogen___2(struct s3 *_X4_dstS2s3_2, signed int _X1ii_2){
+        {
+            ((void)((*_X4_dstS2s3_2)._X1ii_2=_X1ii_2) /* ?{} */);
+        }
+
+    }
+    struct s3 _X2x1S2s3_2;
+    struct s3 _X2y1S2s3_2;
+    struct s4 {
+        signed int _X1ii_2;
+    };
+    inline void _X12_constructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
+        {
+            ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X12_constructorFv_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
+        {
+            ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2) /* ?{} */);
+        }
+
+    }
+    inline void _X11_destructorFv_S2s4_autogen___2(struct s4 *_X4_dstS2s4_2){
+        {
+            ((void)((*_X4_dstS2s4_2)._X1ii_2) /* ^?{} */);
+        }
+
+    }
+    inline struct s4 _X16_operator_assignFS2s4_S2s4S2s4_autogen___2(struct s4 *_X4_dstS2s4_2, struct s4 _X4_srcS2s4_2){
+        struct s4 _X4_retS2s4_2;
+        {
+            ((void)((*_X4_dstS2s4_2)._X1ii_2=_X4_srcS2s4_2._X1ii_2));
+        }
+
+        {
+            ((void)_X12_constructorFv_S2s4S2s4_autogen___2((&_X4_retS2s4_2), (*_X4_dstS2s4_2)));
+        }
+
+        return _X4_retS2s4_2;
+    }
+    inline void _X12_constructorFv_S2s4i_autogen___2(struct s4 *_X4_dstS2s4_2, signed int _X1ii_2){
+        {
+            ((void)((*_X4_dstS2s4_2)._X1ii_2=_X1ii_2) /* ?{} */);
+        }
+
+    }
+    struct s4 _X2x2S2s4_2;
+    struct s4 _X2y2S2s4_2;
+    signed int _X2m1A0i_2[((unsigned long int )10)];
+    signed int _X2m2A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
+    signed int _X2m3A0A0i_2[((unsigned long int )10)][((unsigned long int )10)];
+    {
+        ((void)(_X12_retval_maini_1=0) /* ?{} */);
+    }
+
+    return _X12_retval_maini_1;
+    {
+        ((void)(_X12_retval_maini_1=0) /* ?{} */);
+    }
+
+    return _X12_retval_maini_1;
+}
 static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return _X4mainFi_iPPKc__1((signed int )argc, (const char **)argv); }
 static inline signed int invoke_main(signed int argc, char **argv, char **envp);
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
-          __attribute__ ((unused)) signed int _X12_retval_maini_1;
-          {
-            signed int _tmp_cp_ret4;
-            ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
-          }
-
-          return _X12_retval_maini_1;
-        }
+    __attribute__ ((unused)) signed int _X12_retval_maini_1;
+    {
+        signed int _tmp_cp_ret4;
+        ((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4)) /* ?{} */);
+    }
+
+    return _X12_retval_maini_1;
+}